File: //usr/lib/python3/dist-packages/twisted/conch/test/__pycache__/test_endpoints.cpython-38.pyc
U
��W[!� � @ s� d Z ddlZddlmZ ddlmZ ddlZddlm Z m
Z
ddl m Z ddl
mZmZ ddlmZmZ dd lmZ dd
lmZ dd lmZ dd lmZ dd
lm Z m Z ddl m Z m Z ddl!m"Z"m#Z#m$Z$m%Z% ddl&m'Z'm(Z( ddl)m*Z* ddl+m,Z, ddl-m.Z.m/Z/ ddl&m0Z0m1Z1 ddl2m3Z3 ddl4m5Z5 ddl6m7Z7 ddl8m9Z9m:Z:m;Z; ed��r.ed��r.ddl<m=Z= dd l>m?Z? dd l@mAZA dd lBmCZC dd lDmEZE dd lFmGZG dd!lHmIZI dd"lJmKZKmLZL dd#lMmNZNmOZO dd$lPmQZQ dd%lRmSZSmTZTmUZUmVZV dd&lWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^ dd'l_m`Z` n(d(Zaeb Z? ZA ZC ZE ZG ZI ZK ZNZQdd)l-mcZc dd*ldmeZemfZf G d+d,� d,ee�ZgG d-d.� d.eG�ZhG d/d0� d0eG�ZiG d1d2� d2eG�ZjG d3d4� d4eb�ZkG d5d6� d6e �ZlG d7d8� d8eb�ZmG d9d:� d:eA�ZnG d;d<� d<e?�Zoe e �G d=d>� d>eb��Zpe e �G d?d@� d@eb��ZqG dAdB� dBeb�ZrG dCdD� dDe,er�ZsG dEdF� dFe,er�ZtG dGdH� dHe,�ZuG dIdJ� dJeb�ZvG dKdL� dLe,�ZwdS )Mz'
Tests for L{twisted.conch.endpoints}.
� N)�pack)�ENOSYS)� verifyObject� verifyClass)� implementer)�globalLogPublisher�LogLevel)� iteritems�
networkString)�Failure)�FilePath)�msg)�
requireModule)�IAddress�IStreamClientEndpoint)�Factory�Protocol)�CancelledError�Deferred�succeed�fail)�ConnectionDone�ConnectionRefusedError)� IPv4Address)�TestCase)�EventLoggingObserver�MemoryReactorClock)�ProcessTerminated�ConnectingCancelledError)�Portal)�'InMemoryUsernamePasswordDatabaseDontUse)�
IConchUser)�
ConchError�UserRejectedKey�HostKeyChangedZ cryptographyz pyasn1.type)�common)�
SSHFactory)�SSHUserAuthServer)�
SSHConnection)�Key)�
SSHChannel)�SSHAgentServer)�KnownHostsFile� ConsoleUI)�SSHPublicKeyChecker�InMemorySSHKeyDB)� ConchUser)�publicRSA_openssh�privateRSA_openssh� privateRSA_openssh_encrypted_aes�privateDSA_openssh)�_ISSHConnectionCreator�AuthenticationFailed�SSHCommandAddress�SSHCommandClientEndpoint� _ReadFile�_NewConnectionHelper�_ExistingConnectionHelper)�SSHClientTransportz%can't run w/o cryptography and pyasn1)�StringTransport)�
FakeTransport�connectc @ s e Zd ZdZdZdd� ZdS )�AbortableFakeTransportzC
A L{FakeTransport} with added C{abortConnection} support.
Fc C s
d| _ dS )z}
Abort the connection in a fake manner.
This should really be implemented in the underlying module.
TN��aborted��self� rE �C/usr/lib/python3/dist-packages/twisted/conch/test/test_endpoints.py�abortConnectionN s z&AbortableFakeTransport.abortConnectionN)�__name__�
__module__� __qualname__�__doc__rB rG rE rE rE rF r@ G s r@ c @ s e Zd ZdZdd� ZdS )�BrokenExecSessionzO
L{BrokenExecSession} is a session on which exec requests always fail.
c C s 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 rE �rD �datarE rE rF � request_exec\ s
z BrokenExecSession.request_execN�rH rI rJ rK rO rE rE rE rF rL X s rL c @ s e Zd ZdZdd� ZdS )�WorkingExecSessionzS
L{WorkingExecSession} is a session on which exec requests always succeed.
c C s dS )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}
� rE rM rE rE rF rO n s
z WorkingExecSession.request_execNrP rE rE rE rF rQ j s rQ c @ s e Zd ZdZdd� ZdS )�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 rM rE rE rF rO � s
z#UnsatisfiedExecSession.request_execNrP rE rE rE rF rS | s rS c @ s e Zd Zdd� Zdd� ZdS )� TrivialRealmc C s
i | _ d S �N)�
channelLookuprC rE rE rF �__init__� s zTrivialRealm.__init__c G s t � }| j|_t|dd� fS )Nc S s d S rU rE rE rE rE rF �<lambda>� � z,TrivialRealm.requestAvatar.<locals>.<lambda>)r0 rV r! )rD ZavatarIdZmindZ
interfacesZavatarrE rE rF �
requestAvatar� s zTrivialRealm.requestAvatarN)rH rI rJ rW rZ rE rE rE rF rT � s rT c @ s e Zd ZdZdd� ZdS )�AddressSpyFactoryNc C s || _ t�| |�S rU )�addressr �
buildProtocol)rD r\ rE rE rF r] � s z AddressSpyFactory.buildProtocol)rH rI rJ r\ r] rE rE rE rF r[ � s r[ c @ s$ e Zd Zdd� Zdd� Zdd� ZdS )�FixedResponseUIc C s
|| _ d S rU ��result)rD r` rE rE rF rW � s zFixedResponseUI.__init__c C s
t | j�S rU )r r` �rD �textrE rE rF �prompt� s zFixedResponseUI.promptc C s d S rU rE ra rE rE rF �warn� s zFixedResponseUI.warnN)rH rI rJ rW rc rd rE rE rE rF r^ � s r^ c @ s$ e Zd Zedd� �Zedd� �ZdS )�FakeClockSSHUserAuthServerc C s
| j jjS )zy
Use the C{attemptsBeforeDisconnect} value defined by the factory to make
it easier to override.
)� transport�factory�attemptsBeforeDisconnectrC rE rE rF rh � s z3FakeClockSSHUserAuthServer.attemptsBeforeDisconnectc C s
| j jjS )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).
)rf rg �reactorrC rE rE rF �clock� s z FakeClockSSHUserAuthServer.clockN)rH rI rJ �propertyrh rj rE rE rE rF re � s
re c @ s2 e Zd Zedd� �Zedd� �Zeed�ZdZ dS )�CommandFactoryc C s dt jtd�iS �N� ssh-rsa)rN )r) �
fromStringr1 rC rE rE rF �
publicKeys� s
�zCommandFactory.publicKeysc C s dt jtd�iS rm )r) ro r2 rC rE rE rF � privateKeys� s
�zCommandFactory.privateKeys)s ssh-userauths ssh-connectionr N)
rH rI rJ rk rp rq re r( �servicesrh rE rE rE rF rl � s
� rl c @ s e Zd ZdS )�
MemoryAddressN)rH rI rJ rE rE rE rF rs � s rs c @ s 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)rD �serverrE rE rF rW � s z SingleUseMemoryEndpoint.__init__c C sf | j d k rtd��z|�t� �}W n t� Y S X t| jt| jdd�|t|dd��| _ t|�S d S )Nz(SingleUseMemoryEndpoint was already usedT��isServerF) ru � Exceptionr] rs r r? rv r@ r )rD rg �protocolrE rE rF r? � s
�
�z SingleUseMemoryEndpoint.connectN)rH rI rJ rK rW r? rE rE rE rF rt � s
rt 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 passwordZTCPz10.0.0.1i90 z192.168.100.200i1� )�hostname�port�user�passwordr ri rT �realmr �portalr ZpasswdDBZaddUser�registerCheckerrl rg ZdoStart�
addCleanupZdoStopr �
clientAddress�
serverAddressrC rE rE rF �setUp s"
z(SSHCommandClientEndpointTestsMixin.setUpc C s t d| jjf ��dS )z�
Create and return a new L{SSHCommandClientEndpoint} to be tested.
Override this to implement creation in an interesting way the endpoint.
z%r did not implement createN��NotImplementedError� __class__rH rC rE rE rF �create2 s �z)SSHCommandClientEndpointTestsMixin.createc C s t d| jjf ��dS )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 assertClientTransportStateNr� �rD �clientZimmediateCloserE rE rF �assertClientTransportState; s
��z=SSHCommandClientEndpointTestsMixin.assertClientTransportStatec C s t d| jjf ��dS )z�
Do any remaining work necessary to complete an in-memory connection
attempted initiated using C{self.reactor}.
z%%r did not implement finishConnectionNr� rC rE rE rF �finishConnectionK s
��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)ry Z hostAddressZ peerAddressT)r] r@ r� r� r? )rD Z
serverFactoryZ
clientFactoryZclientProtocolZserverProtocolZclientTransportZserverTransportru rE rE rF �connectedServerAndClientU 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 rR � unknown channelFN)r� r r r{ r? r� �flushLoggedErrorsr" �assertIn�valuerN � assertEqual�len�failureResultOf�trapr� ) rD �endpointrg � connectedrw r� ru �errors�frE rE rF �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)rL r� rV r� r r r{ r? r� r� r� r" r� r� r� �rD r� rg r� rw r� ru r� rE rE rF �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)rS r� rV r� r r r{ r? r� �cancelr� r� r r� r� rE rE rF �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)rQ r� rV r� r[ r r{ r? r� �assertIsInstancer\ r7 r� rf ZgetHostrw r ZusernameZcommand)rD r� rg rw r� ru rE rE rF �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) rQ r� rV r� r r r{ r? r� �successResultOf�assertIsNotNonerf �rD r� rg r� rw r� ru r{ rE rE rF �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, worldrY N)rQ r� rV r� r r r{ r? r� r� �append� dataReceivedrf �id�service�channels�writeru r� �join)
rD r� rg r� rw r� ru r{ r� � channelIdrE rE rF �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)rQ r� rV r� r r r{ r? r� r� r� �connectionLostrf r� r� r� �loseConnectionru r� r r� )
rD r� rg r� rw r� ru r{ r� r� rE rE rF �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 )rQ r� rV r� r r r{ r? r� r� r� r� rf r� r� r� Z sendRequestr� ru r� )
rD ZrequestZ
requestArgr� rg r� rw r� ru r{ r� r� ZchannelrE rE rF �_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 )rD �exitCode�excrE rE rF �test_zeroExitCode9 s z4SSHCommandClientEndpointTestsMixin.test_zeroExitCodec C sH d}d}| � dtd|��}|�t� | �||jj� | �||jj� dS )r� �{ Nr� r� )r� r r� r r� r� r� �signal)rD r� r� r� rE rE rF �test_nonZeroExitStatusD 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� rY s TERM� s messages en-USs exit-signalz'twisted.conch.endpoints._CommandChannelT�message)Z log_levelZ
log_namespaceZshortSignalNameZ
coreDumpedZ errorMessageZ languageTag)r r Z addObserverr� ZremoveObserverr� r% ZNSr� r� r r� r� r� r� �hamcrestZ assert_thatZhas_itemZ has_entriesZequal_tor �info)rD Z logObserverr� r� Zpacketr� Z logNamespacerE rE rF �test_nonZeroExitSignalR 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 rU )r� rE �ZrecorderrE rF rX � rY z;SSHCommandClientEndpointTestsMixin.record.<locals>.<lambda>)rf r� r� �setattrr� r� )rD rw r{ Zevent�noArgsr� r� rE r� rF �record} 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� rY N)rQ r� rV r� r r r{ r? r� r� r� rf r� ru r� r� � rD r� rg r� rw r� ru r{ r� rE rE rF �
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� rY N)rQ r� rV r� r r r{ r? r� r� r� rf Z
writeSequenceru r� r� r� rE rE rF �test_writeSequence� s
z5SSHCommandClientEndpointTestsMixin.test_writeSequenceN)F)rH rI rJ rK r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rE rE rE rF 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.
rn N)r| r� r �mktempZ hostKeyPathr, �
knownHosts�
addHostKeyr} rg rp r
r� �host�saverC rE rE rF 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) r8 �
newConnectionri r r} r~ r� r� r^ rC rE rE rF 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� rg ri �
tcpClientsrC rE rE rF 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� rf r� ru r� ZreportDisconnect)rD rw r� r{ ru r� rE rE rF �loseConnectionToServer� s
z)NewConnectionTests.loseConnectionToServerc C s& |r| � |jj� n| � |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)�
assertTruerf rB �
disconnectingr� rE rE rF r� s z-NewConnectionTests.assertClientTransportStatec C s, t �| jdd| j| j�}| �tt|�� dS )zY
L{SSHCommandClientEndpoint} instances provide L{IStreamClientEndpoint}.
�
dummy command�
dummy userN)r8 r� ri r} r~ r� r r �rD r� rE rE rF �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�r8 r� ri r} r� Z_creatorr~ r� rE rE rF �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� rE rE rF �test_specifiedPort6 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 rR N)r8 r� ri r r} r~ r� r� r^ r r r{ r? r� r� r
r� )rD r� rg r� r~ ZtimeoutZ bindAddressrE rE rF �test_destination@ 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)r8 r� ri r} r~ r� r^ r r r{ r? r� ZclientConnectionFailedr r r� r� �rD r� rg �drE rE rF �test_connectionFailedS 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)r8 r� ri r} r~ r, r� r^ r r r{ r? r� rg r� r� r� r# r� rE rE rF �test_userRejectedHostKeyg 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)Z
passphraseTr� r� � dummy passwordr� r r� N) r) ro r2 �publicr, r r� r� r
r� r� r3 r} r^ r8 r� ri r~ r r r{ r? r� rg r� r� r� r$ ) rD ZfirstKeyr� Z differentKeyr� r� rg r� rw r� ru r� rE rE rF �test_mismatchedHostKey~ s<
��
�
�
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)r8 r� ri r} r~ r� r^ r r r{ r? r= r� r] �makeConnectionr� r r r� r� �rD r� rg r� rf r� rE rE rF �!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� Nrx r r� )r8 r� ri r} r~ r� r^ r r r{ r? r@ r� r] r� r� r� r� r r� rB r� r r r� rE rE rF �$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)r8 r� ri r} r~ r� r^ r r r{ r? r� r� r� r r� Z
connectorsZstoppedConnectingr� rE rE rF �'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� r� Fr� r r� N)r8 r� ri r} r~ r� r^ r r r{ r? r� rg r� Zadvancer� Z
passwordDelay�flushr� r� r6 r� r� rE rE rF �"test_passwordAuthenticationFailure� s, �
�
z5NewConnectionTests.test_passwordAuthenticationFailurec C s0 t dd� t|�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$ g | ] \}}|t �|��� gf�qS rE )r) ro r� )�.0�k�vrE rE rF �
<listcomp> s �z6NewConnectionTests.setupKeyChecker.<locals>.<listcomp>N)�dictr r. r/ r� )rD r� Zusers�mappingZcheckerrE rE rF �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)r) ro r2 r� r� r r4 r8 r� ri r} r~ r� r^ r r r{ r? r� rg r� r� r� r6 r� rf r� ) rD �badKeyr� rg r� rw r� ru r� rE rE rF �#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)r� r� r� r� rR r r� r� r� N)$r) ro r2 r� r� r r4 r8 r� ri r} r~ r� r� r^ r r r{ r? rg rh r� r� ru r� r" r� r� rN r� r� r� r� r� rf r� )
rD r r� rg r� rw r� ru r� r� rE rE rF �test_authenticationFallbackB s@
�
�
�
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� Fr� r r� N)r) ro r4 r� r� r rQ r� rV r8 r� ri r} r~ r� r^ r r r{ r? r� rg r� r� r� rf ) rD �keyr� rg r� rw r� ru r{ rE rE rF � test_publicKeyAuthenticationl 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)r8 r� ri r r} r~ r� r^ r r r{ r? r� rg r� ru r� r� r6 r� rf r� r� rE rE rF � 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.
rY r� F)r� r� �
agentEndpointr� r r� � N)$r) ro r2 r+ r rg Zblobr� r� r� r rt r8 r� ri r} r~ r� r^ rQ r� rV r r{ r? r� r� �rangeru r� r� rf r� r� r� ZclientIO) rD r Z agentServerr r� rg r� rw r� ru �ir{ rE rE rF �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)rQ r� rV r� r r r{ r? r� r� r� r� rf r� r� rE rE rF �test_loseConnection� s
z&NewConnectionTests.test_loseConnectionN)rH rI rJ rK r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r r r r r
r rE rE rE rF r� � s0 $
& " *-r� c @ s0 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� rn r� Fr� N)r| r� r, r r� r� r} rg rp r
r� r� r8 r� ri r r~ r� r^ r� )rD r� rE rE rF r� � s(
�
� �z ExistingConnectionTests.setUpc C s� t � }t|_| j�|�}| jj�� }z0t
| jjd< | � | j | j
jd d �\}}}W 5 | jj�� | jj� |� X || _|| _|| _| �|�}|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� rV �copy�clear�updaterQ r� rg ri r� rv �_client�_pumpr� rf Zconnr8 ZexistingConnection) rD rg r� rV rw r� ru r{ �
connectionrE rE rF r� � 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.
)r ru rv r rC rE rE rF r� 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)� assertFalserf r� rB r� rE rE rF r� + s z2ExistingConnectionTests.assertClientTransportStateN)rH rI rJ rK r� r� r� r� rE rE rE rF r � s
r c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) � ExistingConnectionHelperTestsz1
Tests for L{_ExistingConnectionHelper}.
c C s | � ttt�� dS )zT
L{_ExistingConnectionHelper} implements L{_ISSHConnectionCreator}.
N)r� r r5 r; rC rE rE rF r� ; s �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� ZsecureConnection)rD r` �helperrE rE rF �test_secureConnectionC s �z3ExistingConnectionHelperTests.test_secureConnectionc C s 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; r �cleanupConnection�rD r rE rE rF �$test_cleanupConnectionNotImmediatelyO s
zBExistingConnectionHelperTests.test_cleanupConnectionNotImmediatelyc C s t t� �}|�t� d� dS )z�
L{_ExistingConnectionHelper.cleanupConnection} does nothing to the
existing connection if called with C{immediate} set to C{True}.
TNr r rE rE rF �!test_cleanupConnectionImmediately[ s
z?ExistingConnectionHelperTests.test_cleanupConnectionImmediatelyN)rH rI rJ rK r� r r r rE rE rE rF r 7 s
r c @ s e Zd ZdZdd� Zdd� ZdS )�_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)rD r rE rE rF rW m s z_PTYPath.__init__c C s |dkrt | j�S ttd��dS )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 implementedN)r9 r �OSErrorr )rD �moderE rE rF �openu s
z
_PTYPath.openN)rH rI rJ rK rW r" rE rE rE rF r h s r 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 s | � ttt�� dS )zO
L{_NewConnectionHelper} implements L{_ISSHConnectionCreator}.
N)r� r r5 r: rC rE rE rF r� � s �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_HOSTSrC rE rE rF �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 rU rE )�clsr_ rE rF rX � rY zANewConnectionHelperTests.test_defaultKnownHosts.<locals>.<lambda>N)r �patchr: r r� r rE r_ rF �test_defaultKnownHosts� s �z/NewConnectionHelperTests.test_defaultKnownHostsc C s� t � jd }t| �� �}t|�}|�d|� |�� td|jf � t j�
d�}|j� |d�}| � t
d|� td|f � 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.
rn s 127.0.0.1z Created known_hosts file at %rz~/r$ z Patched _KNOWN_HOSTS with %rN)rl rp r r� r, r� r� r
�path�os�
expanduser�replacer( r: r& r� Z
hasHostKey)rD r r* r� �home�defaultZloadedrE rE rF �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- r rE rE rF �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?)r r: r� r� rc r� �rD �ttyr r` rE rE rF �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� rc r r2 rE rE rF � 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 r3 r rE rE rF �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: r( r= rf r r� r� )rD r r rE rE rF r � 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 @ s e Zd ZdZdd� ZdS )zMNewConnectionHelperTests.test_cleanupConnectionImmediately.<locals>.AbortableFc S s
d| _ dS )z7
Abort the connection.
TNrA rC rE rE rF rG s z]NewConnectionHelperTests.test_cleanupConnectionImmediately.<locals>.Abortable.abortConnectionN)rH rI rJ rB rG rE rE rE rF � Abortable� s r7 NT)r: r( r< rf r r� rB )rD r7 r r rE rE rF r � s$ �
z:NewConnectionHelperTests.test_cleanupConnectionImmediatelyN)rH rI rJ rK r� r% r) r0 r1 r4 r5 r6 r r rE rE rE rF r# � s
r# )xrK �os.pathr+ Zstructr �errnor r� Zzope.interface.verifyr r Zzope.interfacer Ztwisted.loggerr r Ztwisted.python.compatr r
Ztwisted.python.failurer Ztwisted.python.filepathr Ztwisted.python.logr
Ztwisted.python.reflectr Ztwisted.internet.interfacesr r Ztwisted.internet.protocolr r Ztwisted.internet.deferr r r r Ztwisted.internet.errorr r Ztwisted.internet.addressr Ztwisted.trial.unittestr Ztwisted.test.proto_helpersr r r r Ztwisted.cred.portalr Ztwisted.cred.checkersr Ztwisted.conch.interfacesr! Ztwisted.conch.errorr" r# r$ Ztwisted.conch.sshr% Ztwisted.conch.ssh.factoryr& Ztwisted.conch.ssh.userauthr' Z twisted.conch.ssh.connectionr( Ztwisted.conch.ssh.keysr) Ztwisted.conch.ssh.channelr* Ztwisted.conch.ssh.agentr+ Z twisted.conch.client.knownhostsr, r- Ztwisted.conch.checkersr. r/ Ztwisted.conch.avatarr0 Ztwisted.conch.test.keydatar1 r2 r3 r4 Ztwisted.conch.endpointsr5 r6 r7 r8 r9 r: r; Ztwisted.conch.ssh.transportr< �skipr r= Ztwisted.test.iosimr> r? r@ rL rQ rS rT r[ r^ re rl rs rt r| r� r r r r# rE rE rE rF �<module> s� $��� % 9 "S1