File: //usr/lib/python3/dist-packages/twisted/conch/test/__pycache__/test_endpoints.cpython-310.pyc
o
�bP� � @ s� d Z ddlZddlmZ ddlmZ ddlmZ ddl m
Z
m Z ddl Z ddl
mZmZmZ ddlmZ dd lmZ dd
lmZ dd lmZ dd lmZmZm Z m Z dd
l m Z m Z m!Z!m"Z" ddl#m$Z$m%Z% ddl&m'Z'm(Z( ddl)m*Z*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1 ddl2m3Z3 ddl4m5Z5 ddl6m7Z7m8Z8 ddl9m:Z: e5d��re5d��rddl;m<Z< ddl=m>Z>m?Z? dd l@mAZAmBZB dd lCmDZDmEZEmFZFmGZGmHZHmIZImJZJ dd lKmLZL dd lMmNZN dd lOmPZP dd!lQmRZR dd"lSmTZT dd#lUmVZV dd$lWmXZX dd%lYmZZZ dd&l[m\Z\m]Z]m^Z^m_Z_ nd'Z`eaZTeaZZeaZReaZVeaZPeaZNeaZBeaZ?eaZ<dd(lbmcZcmdZd dd)l6meZe G d*d+� d+ec�ZfG d,d-� d-eP�ZgG d.d/� d/eP�ZhG d0d1� d1eP�ZiG d2d3� d3�ZjG d4d5� d5e'�ZkG d6d7� d7�ZlG d8d9� d9eZ�ZmG d:d;� d;eT�Znee$�G d<d=� d=��Zoee%�G d>d?� d?��ZpG d@dA� dA�ZqG dBdC� dCe:eq�ZrG dDdE� dEe:eq�ZsG dFdG� dGe:�ZtG dHdI� dI�ZuG dJdK� dKe:�ZvdS )Lz'
Tests for L{twisted.conch.endpoints}.
� N)�ENOSYS)�pack)� implementer)� verifyClass� verifyObject)�
ConchError�HostKeyChanged�UserRejectedKey)�
IConchUser)�'InMemoryUsernamePasswordDatabaseDontUse)�Portal)� IPv4Address)�CancelledError�Deferred�fail�succeed)�ConnectingCancelledError�ConnectionDone�ConnectionRefusedError�ProcessTerminated)�IAddress�IStreamClientEndpoint)�Factory�Protocol)�LogLevel�globalLogPublisher)�
networkString)�Failure)�FilePath)�msg)�
requireModule)�EventLoggingObserver�MemoryReactorClock)�TestCase� cryptographyz pyasn1.type)� ConchUser)�InMemorySSHKeyDB�SSHPublicKeyChecker)� ConsoleUI�KnownHostsFile)�AuthenticationFailed�SSHCommandAddress�SSHCommandClientEndpoint�_ExistingConnectionHelper�_ISSHConnectionCreator�_NewConnectionHelper� _ReadFile)�common)�SSHAgentServer)�
SSHChannel)�
SSHConnection)�
SSHFactory)�Key)�SSHClientTransport)�SSHUserAuthServer)�privateDSA_openssh�privateRSA_openssh� privateRSA_openssh_encrypted_aes�publicRSA_opensshz%can't run w/o cryptography and pyasn1)�
FakeTransport�connect)�StringTransportc @ s e Zd ZdZdZdd� ZdS )�AbortableFakeTransportzC
A L{FakeTransport} with added C{abortConnection} support.
Fc C �
d| _ dS )z}
Abort the connection in a fake manner.
This should really be implemented in the underlying module.
TN��aborted��self� rF �C/usr/lib/python3/dist-packages/twisted/conch/test/test_endpoints.py�abortConnectionZ �
z&AbortableFakeTransport.abortConnectionN)�__name__�
__module__� __qualname__�__doc__rC rH rF rF rF rG r@ S s r@ c @ � e Zd ZdZdd� ZdS )�BrokenExecSessionzO
L{BrokenExecSession} is a session on which exec requests always fail.
c C � dS )z�
Fail all exec requests.
@param data: Information about what is being executed.
@type data: L{bytes}
@return: C{0} to indicate failure
@rtype: L{int}
r rF �rE �datarF rF rG � request_exech �
z BrokenExecSession.request_execN�rJ rK rL rM rS rF rF rF rG rO c � rO c @ rN )�WorkingExecSessionzS
L{WorkingExecSession} is a session on which exec requests always succeed.
c C rP )z�
Succeed all exec requests.
@param data: Information about what is being executed.
@type data: L{bytes}
@return: C{1} to indicate success
@rtype: L{int}
� rF rQ rF rF rG rS z rT z WorkingExecSession.request_execNrU rF rF rF rG rW u rV rW c @ rN )�UnsatisfiedExecSessionz�
L{UnsatisfiedExecSession} is a session on which exec requests are always
delayed indefinitely, never succeeding or failing.
c C s t � S )z�
Delay all exec requests indefinitely.
@param data: Information about what is being executed.
@type data: L{bytes}
@return: A L{Deferred} which will never fire.
@rtype: L{Deferred}
)r rQ rF rF rG rS � s
z#UnsatisfiedExecSession.request_execNrU rF rF rF rG rY � s rY c @ s e Zd Zdd� Zdd� ZdS )� TrivialRealmc C s
i | _ d S �N)�
channelLookuprD rF rF rG �__init__� �
zTrivialRealm.__init__c G s t � }| j|_t|dd� fS )Nc S � d S r[ rF rF rF rF rG �<lambda>� � z,TrivialRealm.requestAvatar.<locals>.<lambda>)r% r\ r
)rE �avatarId�mind�
interfaces�avatarrF rF rG �
requestAvatar� s zTrivialRealm.requestAvatarN)rJ rK rL r] rf rF rF rF rG rZ � s rZ c @ s e Zd ZdZdd� ZdS )�AddressSpyFactoryNc C s || _ t�| |�S r[ )�addressr �
buildProtocol)rE rh rF rF rG ri � s z AddressSpyFactory.buildProtocol)rJ rK rL rh ri rF rF rF rG rg � � rg c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�FixedResponseUIc C s
|| _ d S r[ ��result)rE rm rF rF rG r] � r^ zFixedResponseUI.__init__c C s
t | j�S r[ )r rm �rE �textrF rF rG �prompt� r^ zFixedResponseUI.promptc C r_ r[ rF rn rF rF rG �warn� s zFixedResponseUI.warnN)rJ rK rL r] rp rq rF rF rF rG rk � s rk c @ s$ e Zd Zedd� �Zedd� �ZdS )�FakeClockSSHUserAuthServerc C �
| j jjS )zy
Use the C{attemptsBeforeDisconnect} value defined by the factory to make
it easier to override.
)� transport�factory�attemptsBeforeDisconnectrD rF rF rG rv � rI z3FakeClockSSHUserAuthServer.attemptsBeforeDisconnectc C rs )z�
Use the reactor defined by the factory, rather than the default global
reactor, to simplify testing (by allowing an alternate implementation
to be supplied by tests).
)rt ru �reactorrD rF rF rG �clock� s
z FakeClockSSHUserAuthServer.clockN)rJ rK rL �propertyrv rx rF rF rF rG rr � s
rr c @ s2 e Zd Zedd� �Zedd� �Zeed�ZdZ dS )�CommandFactoryc C � dt jtd�iS �N� ssh-rsa)rR )r6 �
fromStringr< rD rF rF rG �
publicKeys� � zCommandFactory.publicKeysc C r{ r| )r6 r~ r: rD rF rF rG � privateKeys� r� zCommandFactory.privateKeys)s ssh-userauths ssh-connectionr N)
rJ rK rL ry r r� rr r4 �servicesrv rF rF rF rG rz � s
� rz c @ s e Zd ZdS )�
MemoryAddressN)rJ rK rL rF rF rF rG r� � s r� c @ � e Zd ZdZdd� Zdd� ZdS )�SingleUseMemoryEndpointa]
L{SingleUseMemoryEndpoint} is a client endpoint which allows one connection
to be set up and then exposes an API for moving around bytes related to
that connection.
@ivar pump: L{None} until a connection is attempted, then a L{IOPump}
instance associated with the protocol which is connected.
@type pump: L{IOPump}
c C s d| _ || _dS )z�
@param server: An L{IProtocol} provider to which the client will be
connected.
@type server: L{IProtocol} provider
N)�pump�_server)rE �serverrF rF rG r] � s
z SingleUseMemoryEndpoint.__init__c C sh | j d ur td��z|�t� �}W n ty t� Y S w t| jt| jdd�|t|dd��| _ t |�S )Nz(SingleUseMemoryEndpoint was already usedT��isServerF)
r� � Exceptionri r� �
BaseExceptionr r> r� r@ r )rE ru �protocolrF rF rG r> � s
�
�z SingleUseMemoryEndpoint.connectN)rJ rK rL rM r] r> rF rF rF rG r� � s
r� c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd*d#d$�Zd%d&� Zd'd(� Zd)S )+�"SSHCommandClientEndpointTestsMixina�
Tests for L{SSHCommandClientEndpoint}, an L{IStreamClientEndpoint}
implementations which connects a protocol with the stdin and stdout of a
command running in an SSH session.
These tests apply to L{SSHCommandClientEndpoint} whether it is constructed
using L{SSHCommandClientEndpoint.existingConnection} or
L{SSHCommandClientEndpoint.newConnection}.
Subclasses must override L{create}, L{assertClientTransportState}, and
L{finishConnection}.
c C s� d| _ d| _d| _d| _t� | _t� | _t| j�| _ t
� | _ | j � | j| j� | j �
| j � t� | _| j| j_| j | j_ | j�� | �| jj� tddd�| _tddd �| _d S )
Ns ssh.example.comi&� s users password�TCPz10.0.0.1i90 z192.168.100.200i1� )�hostname�port�user�passwordr" rw rZ �realmr �portalr �passwdDB�addUser�registerCheckerrz ru �doStart�
addCleanup�doStopr
�
clientAddress�
serverAddressrD rF rF rG �setUp s"
z(SSHCommandClientEndpointTestsMixin.setUpc C � t | jj�d���)z�
Create and return a new L{SSHCommandClientEndpoint} to be tested.
Override this to implement creation in an interesting way the endpoint.
z did not implement create��NotImplementedError� __class__rJ rD rF rF rG �create/ � �z)SSHCommandClientEndpointTestsMixin.createc C s t d| jjf ��)a�
Make an assertion about the connectedness of the given protocol's
transport. Override this to implement either a check for the
connection still being open or having been closed as appropriate.
@param client: The client whose state is being checked.
@param immediateClose: Boolean indicating whether the connection was
closed immediately or not.
z/%r did not implement assertClientTransportStater� �rE �client�immediateCloserF rF rG �assertClientTransportState8 s
��z=SSHCommandClientEndpointTestsMixin.assertClientTransportStatec C r� )z�
Do any remaining work necessary to complete an in-memory connection
attempted initiated using C{self.reactor}.
z# did not implement finishConnectionr� rD rF rF rG �finishConnectionH r� z3SSHCommandClientEndpointTestsMixin.finishConnectionc C sT |� d�}|� d�}t|d| j| jd�}t|d| j| jd�}t||||�}|||fS )aw
Set up an in-memory connection between protocols created by
C{serverFactory} and C{clientFactory}.
@return: A three-tuple. The first element is the protocol created by
C{serverFactory}. The second element is the protocol created by
C{clientFactory}. The third element is the L{IOPump} connecting
them.
NF)r� � hostAddress� peerAddressT)ri r@ r� r� r> )rE �
serverFactory�
clientFactory�clientProtocol�serverProtocol�clientTransport�serverTransportr� rF rF rG �connectedServerAndClientQ s
��
z;SSHCommandClientEndpointTestsMixin.connectedServerAndClientc C s� | � � }t� }t|_|�|�}| �� \}}}| �t�}| �d|d j j
|d j j f� | � dt |�� | �
|�}|�t� | � d|j j � | �|d� dS )z�
If a channel cannot be opened on the authenticated SSH connection, the
L{Deferred} returned by L{SSHCommandClientEndpoint.connect} fires with
a L{Failure} wrapping the reason given by the server.
�unknown channelr rX � unknown channelFN)r� r r r� r> r� �flushLoggedErrorsr �assertIn�valuerR � assertEqual�len�failureResultOf�trapr� ) rE �endpointru � connectedr� r� r� �errors�frF rF rG �test_channelOpenFailuren s
z:SSHCommandClientEndpointTestsMixin.test_channelOpenFailurec C sl t | jjd< | �� }t� }t|_|�|�}| �� \}}}| � |�}|�
t � | � d|j
j
� | �|d� dS )z�
If execution of the command fails, the L{Deferred} returned by
L{SSHCommandClientEndpoint.connect} fires with a L{Failure} wrapping
the reason given by the server.
� sessionzchannel request failedFN)rO r� r\ r� r r r� r> r� r� r� r r� r� r� �rE r� ru r� r� r� r� r� rF rF rG �test_execFailure� s
z3SSHCommandClientEndpointTestsMixin.test_execFailurec C sd t | jjd< | �� }t� }t|_|�|�}| �� \}}}|� � | �
|�}|� t � | �
|d� dS )z�
If execution of the command is cancelled via the L{Deferred} returned
by L{SSHCommandClientEndpoint.connect}, the connection is closed
immediately.
r� TN)rY r� r\ r� r r r� r> r� �cancelr� r� r r� r� rF rF rG �test_execCancelled� s
z5SSHCommandClientEndpointTestsMixin.test_execCancelledc C s� t | jjd< | �� }t� }t|_|�|� | �� \}}}| � |j
t � | � |j
�� |j
j� | � | j|j
j� | � d|j
j� dS )aD
Once the necessary SSH actions have completed successfully,
L{SSHCommandClientEndpoint.connect} uses the factory passed to it to
construct a protocol instance by calling its C{buildProtocol} method
with an address object representing the SSH connection and command
executed.
r� �
/bin/ls -lN)rW r� r\ r� rg r r� r> r� �assertIsInstancerh r+ r� rt �getHostr� r� �username�command)rE r� ru r� r� r� rF rF rG �test_buildProtocol� s
z5SSHCommandClientEndpointTestsMixin.test_buildProtocolc C sR t | jjd< | �� }t� }t|_|�|�}| �� \}}}| � |�}| �
|j � dS )a
L{SSHCommandClientEndpoint} establishes an SSH connection, creates a
channel in it, runs a command in that channel, and uses the protocol's
C{makeConnection} to associate it with a protocol representing that
command's stdin and stdout.
r� N) rW r� r\ r� r r r� r> r� �successResultOf�assertIsNotNonert �rE r� ru r� r� r� r� r� rF rF rG �test_makeConnection� s
z6SSHCommandClientEndpointTestsMixin.test_makeConnectionc
C s� t | jjd< | �� }t� }t|_|�|�}| �� \}}}| � |�}g }|j
|_ |j j
} |jj| �d� |�� | �dd�|�� dS )z�
After establishing the connection, when the command on the SSH server
produces output, it is delivered to the protocol's C{dataReceived}
method.
r� � hello, world� N)rW r� r\ r� r r r� r> r� r� �append� dataReceivedrt �id�service�channels�writer� r� �join)
rE r� ru r� r� r� r� r� r� � channelIdrF rF rG �test_dataReceived� s
z4SSHCommandClientEndpointTestsMixin.test_dataReceivedc
C s� t | jjd< | �� }t� }t|_|�|�}| �� \}}}| � |�}g }|j
|_ |j j
} |jj| �� |�� |d �t� | �|d� dS )zq
When the command closes the channel, the protocol's C{connectionLost}
method is called.
r� r FN)rW r� r\ r� r r r� r> r� r� r� �connectionLostrt r� r� r� �loseConnectionr� r� r r� )
rE r� ru r� r� r� r� r� r� r� rF rF rG �test_connectionLost� s
z6SSHCommandClientEndpointTestsMixin.test_connectionLostc
C s� t | jjd< | �� }t� }t|_|�|�}| �� \}}}| � |�} g }
|
j
| _ | j j
} |jj| } |j�| ||� | �� |�� | �|d� |
d S )zJ
Test handling of non-zero exit statuses or exit signals.
r� Fr )rW r� r\ r� r r r� r> r� r� r� r� rt r� r� r� � sendRequestr� r� r� )
rE �request�
requestArgr� ru r� r� r� r� r� r� r� �channelrF rF rG �_exitStatusTest s
z2SSHCommandClientEndpointTestsMixin._exitStatusTestc C s$ d}| � dtd|��}|�t� dS )��
When the command exits with a non-zero status, the protocol's
C{connectionLost} method is called with a L{Failure} wrapping an
exception which encapsulates that status.
r � exit-status�>LN)r� r r� r )rE �exitCode�excrF rF rG �test_zeroExitCode0 s z4SSHCommandClientEndpointTestsMixin.test_zeroExitCodec C sH d}d}| � dtd|��}|�t� | �||jj� | �||jj� dS )r� �{ Nr� r� )r� r r� r r� r� r� �signal)rE r� r� r� rF rF rG �test_nonZeroExitStatus: s
z9SSHCommandClientEndpointTestsMixin.test_nonZeroExitStatusc C s� t � }t�|� | �tj|� d}d}d�t�d�dt�d�t�d�g�}| �d|�}|� t
� | � ||j j
� | � ||j j� d }t�|t�t�t�tj�|dd
d dd ���� dS )
a
When the command exits with a non-zero signal, the protocol's
C{connectionLost} method is called with a L{Failure} wrapping an
exception which encapsulates that status.
Additional packet contents are logged at the C{info} level.
N� r� s TERM� s messages en-USs exit-signalz'twisted.conch.endpoints._CommandChannelT�message)� log_level�
log_namespace�shortSignalName�
coreDumped� errorMessage� languageTag)r! r � addObserverr� �removeObserverr� r1 �NSr� r� r r� r� r� r� �hamcrest� assert_that�has_item� has_entries�equal_tor �info)rE � logObserverr� r� �packetr� � logNamespacerF rF rG �test_nonZeroExitSignalG s>
��
����z9SSHCommandClientEndpointTestsMixin.test_nonZeroExitSignalFc s< |j j}g � |r� fdd�}n� j}t|jj| ||� � S )a
Hook into and record events which happen to C{protocol}.
@param server: The SSH server protocol over which C{protocol} is
running.
@type server: L{IProtocol} provider
@param protocol:
@param event:
@param noArgs:
c s
� � d �S r[ )r� rF ��recorderrF rG r` � s
z;SSHCommandClientEndpointTestsMixin.record.<locals>.<lambda>)rt r� r� �setattrr� r� )rE r� r� �event�noArgsr� r� rF r rG �recordu s z)SSHCommandClientEndpointTestsMixin.recordc C sz t | jjd< | �� }t� }t|_|�|�}| �� \}}}| � |�}| �
||d�}|j � d� |�
� | �dd�|�� dS )z�
The transport connected to the protocol has a C{write} method which
sends bytes to the input of the command executing on the SSH server.
r� r� r� r� N)rW r� r\ r� r r r� r> r� r� r rt r� r� r� r� � rE r� ru r� r� r� r� r� r� rF rF rG �
test_write� s
z-SSHCommandClientEndpointTestsMixin.test_writec C s| t | jjd< | �� }t� }t|_|�|�}| �� \}}}| � |�}| �
||d�}|j � dg� |�
� | �dd�|�� dS )z�
The transport connected to the protocol has a C{writeSequence} method which
sends bytes to the input of the command executing on the SSH server.
r� r� r� r� N)rW r� r\ r� r r r� r> r� r� r rt �
writeSequencer� r� r� r rF rF rG �test_writeSequence� s
z5SSHCommandClientEndpointTestsMixin.test_writeSequenceN)F)rJ rK rL rM r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r rF rF rF rG r�
s*
. r� c @ s� e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zdd� Zd d � Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0S )1�NewConnectionTestsz`
Tests for L{SSHCommandClientEndpoint} when using the C{newConnection}
constructor.
c C sh t �| � t| �� �| _t| j�| _| j�| j| j j
d � | j�t | j j
�| j j
d � | j�� dS )�
Configure an SSH server with password authentication enabled for a
well-known (to the tests) account.
r} N)r� r� r �mktemp� hostKeyPathr) �
knownHosts�
addHostKeyr� ru r r r� �host�saverD rF rF rG r� � s
�zNewConnectionTests.setUpc
C s* t j| jd| j| j| j| j| jtd�d�S )zu
Create and return a new L{SSHCommandClientEndpoint} using the
C{newConnection} constructor.
r� F�r� r �ui) r, �
newConnectionrw r� r� r� r� r rk rD rF rF rG r� � s �zNewConnectionTests.createc C s | � | j| jjd d �S )z}
Establish the first attempted TCP connection using the SSH server which
C{self.factory} can create.
r � )r� ru rw �
tcpClientsrD rF rF rG r� � s �z#NewConnectionTests.finishConnectionc C sH | j ||ddd�}|j�� |�� | �dg|� |�� |j�� dS )a�
Lose the connection to a server and pump the L{IOPump} sufficiently for
the client to handle the lost connection. Asserts that the client
disconnects its transport.
@param server: The SSH server protocol over which C{protocol} is
running.
@type server: L{IProtocol} provider
@param client: The SSH client protocol over which C{protocol} is
running.
@type client: L{IProtocol} provider
@param protocol: The protocol created by calling connect on the ssh
endpoint under test.
@type protocol: L{IProtocol} provider
@param pump: The L{IOPump} connecting client to server.
@type pump: L{IOPump}
�closedT)r N)r rt r� r� r� �reportDisconnect)rE r� r� r� r� r rF rF rG �loseConnectionToServer� s
z)NewConnectionTests.loseConnectionToServerc C s( |r | � |jj� dS | � |jj� dS )z�
Assert that the transport for the given protocol has been disconnected.
L{SSHCommandClientEndpoint.newConnection} creates a new dedicated SSH
connection and cleans it up after the command exits.
N)�
assertTruert rC �
disconnectingr� rF rF rG r� s z-NewConnectionTests.assertClientTransportStatec C s, t �| jdd| j| j�}| �tt|�� dS )zY
L{SSHCommandClientEndpoint} instances provide L{IStreamClientEndpoint}.
�
dummy command�
dummy userN)r, r rw r� r� r r r �rE r� rF rF rG �test_interface s �z!NewConnectionTests.test_interfacec C s( t �| jdd| j�}| �d|jj� dS )z�
L{SSHCommandClientEndpoint} uses the default port number for SSH when
the C{port} argument is not specified.
r r � N�r, r rw r� r� �_creatorr� r rF rF rG �test_defaultPort" s �z#NewConnectionTests.test_defaultPortc C s, t j| jdd| jdd�}| �d|jj� dS )zU
L{SSHCommandClientEndpoint} uses the C{port} argument if specified.
r r i� )r� Nr# r rF rF rG �test_specifiedPort, s �z%NewConnectionTests.test_specifiedPortc
C s� t j| jd| j| j| j| j| jtd�d�}t � }t
|_ |� |� | jj
d \}}}}}| �| jt|�� | �| j|� | �dt| jj
�� dS )z�
L{SSHCommandClientEndpoint} uses the L{IReactorTCP} passed to it to
attempt a connection to the host/port address also passed to it.
r� Fr r rX N)r, r rw r� r� r� r� r rk r r r� r> r r� r r� )rE r� ru r r� �timeout� bindAddressrF rF rG �test_destination5 s" �
z#NewConnectionTests.test_destinationc C sp t j| jdd| j| j| jtd�d�}t� }t|_ |�
|�}| jj d d }|� dt
t� �� | �|��t� dS )z�
If a connection cannot be established, the L{Deferred} returned by
L{SSHCommandClientEndpoint.connect} fires with a L{Failure}
representing the reason for the connection setup failure.
r� r F�r r r r N)r, r rw r� r� r rk r r r� r> r �clientConnectionFailedr r r� r� �rE r� ru �drF rF rG �test_connectionFailedM s �
z(NewConnectionTests.test_connectionFailedc C sx t j| jdd| j| jt| �� �td�d�}t� }t |_
|� |�}| � | j
| jjd d �\}}}| �|�}|�t� dS )a"
If the L{KnownHostsFile} instance used to construct
L{SSHCommandClientEndpoint} rejects the SSH public key presented by the
server, the L{Deferred} returned by L{SSHCommandClientEndpoint.connect}
fires with a L{Failure} wrapping L{UserRejectedKey}.
r� r Fr* r r N)r, r rw r� r� r) r rk r r r� r> r� ru r r� r� r r� rF rF rG �test_userRejectedHostKeye s"
�
�
z+NewConnectionTests.test_userRejectedHostKeyc
C s� t �t��� }tt| �� ��}|�t| j j
�|� t jt dd��� }|�| j |� t
d�}tj| jdd| j | jd||d�}t� }t|_|�|�}| �| j| jjd d �\}} }
| �|�} | �t� d
S ) ac
If the SSH public key presented by the SSH server does not match the
previously remembered key, as reported by the L{KnownHostsFile}
instance use to construct the endpoint, for that server, the
L{Deferred} returned by L{SSHCommandClientEndpoint.connect} fires with
a L{Failure} wrapping L{HostKeyChanged}.
s testxp)�
passphraseTr� r � dummy passwordr r r N) r6 r~ r: �publicr) r r r r r� r r; r� rk r, r rw r� r r r� r> r� ru r r� r� r ) rE �firstKeyr � differentKeyr r� ru r� r� r� r� r� rF rF rG �test_mismatchedHostKey� s8 ���
�
z)NewConnectionTests.test_mismatchedHostKeyc C s� t j| jdd| j| j| jtd�d�}t� }t|_ |�
|�}t � }| jj d d }|�
d�}|�|� |�tt� �� | �|��t� dS )aU
If the connection closes at any point before the SSH transport layer
has finished key exchange (ie, gotten to the point where we may attempt
to authenticate), the L{Deferred} returned by
L{SSHCommandClientEndpoint.connect} fires with a L{Failure} wrapping
the reason for the lost connection.
r� r Fr* r r N)r, r rw r� r� r rk r r r� r> r? r ri �makeConnectionr� r r r� r� �rE r� ru r- rt r� rF rF rG �!test_connectionClosedBeforeSecure� s$ �
z4NewConnectionTests.test_connectionClosedBeforeSecurec C s� t j| jdd| j| j| jtd�d�}t� }t|_ |�
|�}t ddd�}| jj d d }|�
d�}|�|� |�� | �|��t� | �|j� |�tt� �� dS ) a[
If the connection is cancelled before the SSH transport layer has
finished key exchange (ie, gotten to the point where we may attempt to
authenticate), the L{Deferred} returned by
L{SSHCommandClientEndpoint.connect} fires with a L{Failure} wrapping
L{CancelledError} and the connection is aborted.
r� r Fr* Nr� r r )r, r rw r� r� r rk r r r� r> r@ r ri r6 r� r� r� r r rC r� r r r7 rF rF rG �$test_connectionCancelledBeforeSecure� s( �
z7NewConnectionTests.test_connectionCancelledBeforeSecurec C sj t j| jdd| j| j| jtd�d�}t� }t|_ |�
|�}|� � | � |��
t� | �| jjd j� dS )zz
If the connection is cancelled before it finishes connecting, the
connection attempt is stopped.
r� r Fr* r N)r, r rw r� r� r rk r r r� r> r� r� r� r r �
connectors�stoppedConnectingr, rF rF rG �'test_connectionCancelledBeforeConnected� s �
z:NewConnectionTests.test_connectionCancelledBeforeConnectedc
C s� t j| jdd| j| jd| jtd�d�}t� }t|_ |�
|�}| � | j | jj
d d �\}}}| j�|jj� |�� | �|�}|�t� | �|d� dS ) z�
If the SSH server rejects the password presented during authentication,
the L{Deferred} returned by L{SSHCommandClientEndpoint.connect} fires
with a L{Failure} wrapping L{AuthenticationFailed}.
r� r r1 Fr r r N)r, r rw r� r� r rk r r r� r> r� ru r �advancer� �
passwordDelay�flushr� r� r* r� r� rF rF rG �"test_passwordAuthenticationFailure s* �
�
z5NewConnectionTests.test_passwordAuthenticationFailurec C s, dd� |� � D �}tt|��}|�|� dS )a�
Create an L{ISSHPrivateKey} checker which recognizes C{users} and add it
to C{portal}.
@param portal: A L{Portal} to which to add the checker.
@type portal: L{Portal}
@param users: The users and their keys the checker will recognize. Keys
are byte strings giving user names. Values are byte strings giving
OpenSSH-formatted private keys.
@type users: L{dict}
c S s" i | ]
\}}|t �|��� g�qS rF )r6 r~ r2 )�.0�k�vrF rF rG �
<dictcomp>8 s " z6NewConnectionTests.setupKeyChecker.<locals>.<dictcomp>N)�itemsr' r& r� )rE r� �users�mapping�checkerrF rF rG �setupKeyChecker+ s
z"NewConnectionTests.setupKeyCheckerc
C s� t �t�}| �| j| jti� tj| j d| j| j
| j |g| j t
d�d�}t� }t|_|�|�}| �| j| j jd d �\}}}| �|�}|�t� | �|jj� dS )z�
If the SSH server rejects the key pair presented during authentication,
the L{Deferred} returned by L{SSHCommandClientEndpoint.connect} fires
with a L{Failure} wrapping L{AuthenticationFailed}.
r� F��keysr r r r N)r6 r~ r: rI r� r� r9 r, r rw r� r� r rk r r r� r> r� ru r r� r� r* r rt r ) rE �badKeyr� ru r� r� r� r� r� rF rF rG �#test_publicKeyAuthenticationFailure< s*
�
�
z6NewConnectionTests.test_publicKeyAuthenticationFailurec
C s
t �t�}| �| j| jti� tj| j d| j| j
| j |g| j | j
td�d� }t� }t|_|�|�}| j jd7 _| �| j| j jd d �\}}}|�� | �t�}| �d|d jj |d jjf� | � dt |�� | � |�} | � t� | � d| jj� | �!|j"j#� d S )
z{
If the SSH server does not accept any of the specified SSH keys, the
specified password is tried.
r� F)rK r� r r rX r r r� r� N)$r6 r~ r: rI r� r� r9 r, r rw r� r� r� r rk r r r� r> ru rv r� r r� r� r r� r� rR r� r� r� r� r rt r )
rE rL r� ru r� r� r� r� r� r� rF rF rG �test_authenticationFallbacka s8
�
�
z.NewConnectionTests.test_authenticationFallbackc
C s� t �t�}| �| j| jti� t| jjd< t j
| j d| j| j | j
|g| jtd�d�}t� }t|_|�|�}| �| j| j jd d �\}}}| �|�}| �|j� dS )z�
If L{SSHCommandClientEndpoint} is initialized with any private keys, it
will try to use them to authenticate with the SSH server.
r� r� FrJ r r N)r6 r~ r9 rI r� r� rW r� r\ r, r rw r� r� r rk r r r� r> r� ru r r� r� rt ) rE �keyr� ru r� r� r� r� r� rF rF rG � test_publicKeyAuthentication� s*
�
�
z/NewConnectionTests.test_publicKeyAuthenticationc C s� t j| jd| j| j| j| jtd�d�}t� }t |_
|� |�}| � | j
| jjd d �\}}}|�� | �|�}|�t� | �|jj� dS )z�
If the password is not specified, L{SSHCommandClientEndpoint} doesn't
try it as an authentication mechanism.
r� Fr* r r N)r, r rw r� r� r� r rk r r r� r> r� ru r r� r� r� r* r rt r r� rF rF rG � test_skipPasswordAuthentication� s& �
�
z2NewConnectionTests.test_skipPasswordAuthenticationc
C s t �t�}t� }t� |_|�� |dfi|j_| �| j | j
ti� t |�}t j
| jd| j
| j| j| jtd�|d�}t| jjd< t� }t|_|�|�}| �| j| jjd d �\}}} td�D ] }
|j � � | � � q]| � |�} | � | j � | � ||| | � | �!|j j"� | �!|j j#j"� d S )
a
If L{SSHCommandClientEndpoint} is initialized with an
L{SSHAgentClient}, the agent is used to authenticate with the SSH
server. Once the connection with the SSH server has concluded, the
connection to the agent is disconnected.
r� r� F)r r �
agentEndpointr� r r � N)$r6 r~ r: r2 r ru �blobrK rI r� r� r� r, r rw r� r� r rk rW r� r\ r r� r> r� r �ranger� r� r� rt r r r �clientIO) rE rO � agentServerrR r� ru r� r� r� r� �ir� rF rF rG �test_agentAuthentication� s>
�
�
z+NewConnectionTests.test_agentAuthenticationc C sd t | jjd< | �� }t� }t|_|�|�}| �� \}}}| � |�}| �
||||� | � |j j
� dS )z�
The transport connected to the protocol has a C{loseConnection} method
which causes the channel in which the command is running to close and
the overall connection to be closed.
r� N)rW r� r\ r� r r r� r> r� r� r r rt r r� rF rF rG �test_loseConnection s
z&NewConnectionTests.test_loseConnectionN)rJ rK rL rM r� r� r� r r� r! r% r& r) r. r/ r5 r8 r9 r< r@ rI rM rN rP rQ rY rZ rF rF rF rG r � s2 #
, "(%0 ! 3r c @ �0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) �ExistingConnectionTestsze
Tests for L{SSHCommandClientEndpoint} when using the C{existingConnection}
constructor.
c
C sz t �| � tt| �� ��}|�| j| jjd � |�t | j
j �| jjd � t j
| jd| j| j| j| j|td�d�| _dS )r
r} r� Fr N)r� r� r) r r r r� ru r r r� r r, r rw r� r� r� rk r� )rE r rF rF rG r� ! s
� �z ExistingConnectionTests.setUpc C s� t � }t|_| j�|�}| jj�� }z%t| jjd< | � | j
| j j d d �\}}}W | jj�
� | jj�|� n| jj�
� | jj�|� w || _|| _|| _| �|�}|jj}t�|d�S )zz
Create and return a new L{SSHCommandClientEndpoint} using the
C{existingConnection} constructor.
r� r r r� )r r r� r� r> r� r\ �copyrW r� ru rw r �clear�updater� �_client�_pumpr� rt �connr, �existingConnection) rE ru r� r\ r� r� r� r� �
connectionrF rF rG r� 9 s& � �
z ExistingConnectionTests.createc C s8 | j �� | j �� | j �� | j �� | j| j| j fS )z�
Give back the connection established in L{create} over which the new
command channel being tested will exchange data.
)ra r� r� r` rD rF rF rG r� W s
z(ExistingConnectionTests.finishConnectionc C s | � |jj� | � |jj� dS )a
Assert that the transport for the given protocol is still connected.
L{SSHCommandClientEndpoint.existingConnection} re-uses an SSH connected
created by some other code, so other code is responsible for cleaning
it up.
N)� assertFalsert r rC r� rF rF rG r� e s z2ExistingConnectionTests.assertClientTransportStateN)rJ rK rL rM r� r� r� r� rF rF rF rG r\ s r\ c @ r[ ) � ExistingConnectionHelperTestsz1
Tests for L{_ExistingConnectionHelper}.
c C � | � ttt�� dS )zT
L{_ExistingConnectionHelper} implements L{_ISSHConnectionCreator}.
N)r r r. r- rD rF rF rG r! u � z,ExistingConnectionHelperTests.test_interfacec C s( t � }t|�}| �|| �|�� �� dS )z�
L{_ExistingConnectionHelper.secureConnection} returns a L{Deferred}
which fires with whatever object was fed to
L{_ExistingConnectionHelper.__init__}.
N)�objectr- �assertIsr� �secureConnection)rE rm �helperrF rF rG �test_secureConnection{ s z3ExistingConnectionHelperTests.test_secureConnectionc C � t t� �}|�t� d� dS )z�
L{_ExistingConnectionHelper.cleanupConnection} does nothing to the
existing connection if called with C{immediate} set to C{False}.
FN�r- ri �cleanupConnection�rE rl rF rF rG �$test_cleanupConnectionNotImmediately� �
zBExistingConnectionHelperTests.test_cleanupConnectionNotImmediatelyc C rn )z�
L{_ExistingConnectionHelper.cleanupConnection} does nothing to the
existing connection if called with C{immediate} set to C{True}.
TNro rq rF rF rG �!test_cleanupConnectionImmediately� rs z?ExistingConnectionHelperTests.test_cleanupConnectionImmediatelyN)rJ rK rL rM r! rm rr rt rF rF rF rG rf p s
rf c @ r� )�_PTYPathzk
A L{FilePath}-like object which can be opened to create a L{_ReadFile} with
certain contents.
c C s
|| _ dS )zz
@param contents: L{bytes} which will be the contents of the
L{_ReadFile} this path can open.
N)�contents)rE rv rF rF rG r] � s
z_PTYPath.__init__c C s |dkr t | j�S ttd��)z�
If the mode is r+, return a L{_ReadFile} with the contents given to
this path's initializer.
@raise OSError: If the mode is unsupported.
@return: A L{_ReadFile} instance
zrb+zFunction not implemented)r0 rv �OSErrorr )rE �moderF rF rG �open� s
z
_PTYPath.openN)rJ rK rL rM r] ry rF rF rF rG ru � s ru c @ s` e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd d
� Z dd� Z
dd� Z dd� Z dd� Z
dS )�NewConnectionHelperTestsz,
Tests for L{_NewConnectionHelper}.
c C rg )zO
L{_NewConnectionHelper} implements L{_ISSHConnectionCreator}.
N)r r r. r/ rD rF rF rG r! � rh z'NewConnectionHelperTests.test_interfacec C s | � dtj� dS )zK
The default I{known_hosts} path is I{~/.ssh/known_hosts}.
z~/.ssh/known_hostsN)r� r/ � _KNOWN_HOSTSrD rF rF rG �test_defaultPath� s z)NewConnectionHelperTests.test_defaultPathc sH t � � | �td� fdd�� tdddddddddd�
}| �� |j� dS )z�
L{_NewConnectionHelper._knownHosts} is used to create a
L{KnownHostsFile} if one is not passed to the initializer.
� _knownHostsc s � S r[ rF )�clsrl rF rG r` � ra zANewConnectionHelperTests.test_defaultKnownHosts.<locals>.<lambda>N)ri �patchr/ rj r rq rF rl rG �test_defaultKnownHosts� s �z/NewConnectionHelperTests.test_defaultKnownHostsc C s� t � jd }t| �� �}t|�}|�d|� |�� td|j��� t j�
d�}|j� |d�}| � t
d|� td|��� t
�� }| �|�d|�� dS )z�
Existing entries in the I{known_hosts} file are reflected by the
L{KnownHostsFile} created by L{_NewConnectionHelper} when none is
supplied to it.
r} s 127.0.0.1z Created known_hosts file at z~/r{ zPatched _KNOWN_HOSTS with N)rz r r r r) r r r �path�os�
expanduser�replacer r/ r} r �
hasHostKey)rE rO r� r �home�default�loadedrF rF rG �test_readExisting� s z*NewConnectionHelperTests.test_readExistingc C s, t dddddddddd�
}| �|jt� dS )zz
If L{None} is passed for the C{ui} parameter to
L{_NewConnectionHelper}, a L{ConsoleUI} is used.
N)r/ r� r r( rq rF rF rG �test_defaultConsoleUI� s �z.NewConnectionHelperTests.test_defaultConsoleUIc C sD t d�}tdddddddddd|� }| �|j�d��}| �|� dS )z�
If L{None} is passed for the C{ui} parameter to L{_NewConnectionHelper}
and /dev/tty is available, the L{ConsoleUI} used is associated with
/dev/tty.
s yesNs does this work?)ru r/ r� r rp r �rE �ttyrl rm rF rF rG �test_ttyConsoleUI� s �z*NewConnectionHelperTests.test_ttyConsoleUIc C sH t | �� �}tdddddddddd|� }| �|j�d��}| �|� dS )z�
If L{None} is passed for the C{ui} parameter to L{_NewConnectionHelper}
and /dev/tty is not available, the L{ConsoleUI} used is associated with
some file which always produces a C{b"no"} response.
Ns did this break?)r r r/ r� r rp re r� rF rF rG � test_nottyUI s �z%NewConnectionHelperTests.test_nottyUIc C s0 t dddddddddd�
}| �td�|j� dS )zy
If not passed the name of a tty in the filesystem,
L{_NewConnectionHelper} uses C{b"/dev/tty"}.
Ns /dev/tty)r/ r� r r� rq rF rF rG �test_defaultTTYFilename s �z0NewConnectionHelperTests.test_defaultTTYFilenamec C sF t dddddddddd�
}t� }t� |_|�|d� | �|jj� dS )z�
L{_NewConnectionHelper.cleanupConnection} closes the transport cleanly
if called with C{immediate} set to C{False}.
NF)r/ r4 r? rt rp r r )rE rl rd rF rF rG rr s � z=NewConnectionHelperTests.test_cleanupConnectionNotImmediatelyc C s` G dd� d�}t dddddddddd�
}t� }t� |_|� |j_|�|d� | �|jjj� dS )z�
L{_NewConnectionHelper.cleanupConnection} closes the transport with
C{abortConnection} if called with C{immediate} set to C{True}.
c @ rN )zMNewConnectionHelperTests.test_cleanupConnectionImmediately.<locals>.AbortableFc S rA )z7
Abort the connection.
TNrB rD rF rF rG rH 1 s
z]NewConnectionHelperTests.test_cleanupConnectionImmediately.<locals>.Abortable.abortConnectionN)rJ rK rL rC rH rF rF rF rG � Abortable. rj r� NT)r/ r4 r7 rt rp r rC )rE r� rl rd rF rF rG rt ( s �
z:NewConnectionHelperTests.test_cleanupConnectionImmediatelyN)rJ rK rL rM r! r| r� r� r� r� r� r� rr rt rF rF rF rG rz � s
rz )wrM �os.pathr� �errnor �structr �zope.interfacer �zope.interface.verifyr r r� �twisted.conch.errorr r r �twisted.conch.interfacesr
�twisted.cred.checkersr �twisted.cred.portalr �twisted.internet.addressr
�twisted.internet.deferr r r r �twisted.internet.errorr r r r �twisted.internet.interfacesr r �twisted.internet.protocolr r �twisted.loggerr r �twisted.python.compatr �twisted.python.failurer �twisted.python.filepathr �twisted.python.logr �twisted.python.reflectr �twisted.test.proto_helpersr! r" �twisted.trial.unittestr# �twisted.conch.avatarr% �twisted.conch.checkersr& r' � twisted.conch.client.knownhostsr( r) �twisted.conch.endpointsr* r+ r, r- r. r/ r0 �twisted.conch.sshr1 �twisted.conch.ssh.agentr2 �twisted.conch.ssh.channelr3 � twisted.conch.ssh.connectionr4 �twisted.conch.ssh.factoryr5 �twisted.conch.ssh.keysr6 �twisted.conch.ssh.transportr7 �twisted.conch.ssh.userauthr8 �twisted.conch.test.keydatar9 r: r; r< �skipri �twisted.test.iosimr= r> r? r@ rO rW rY rZ rg rk rr rz r� r� r� r r\ rf ru rz rF rF rF rG �<module> s� $
& 1 dU,