tfdZddlZddlmZddlmZddlmZddl m Z ddl m Z m Z ddlZddlmZmZmZdd lmZdd lmZdd lmZdd lmZdd lmZmZmZmZddl m!Z!m"Z"m#Z#m$Z$ddl%m&Z&m'Z'ddl(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.ddl/m0Z0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAmBZBddlCmDZDmEZEddlFmGZGmHZHmIZImJZJmKZKmLZLddlMmNZNddlOmPZPdd lQmRZRdd!lSmTZTdd"lUmVZVdd#lWmXZXdd$lYmZZZdd%l[m\Z\dd&l]m^Z^m_Z_m`Z`maZand'ZbecZVecZ\ecZTecZXecZRecZPecZEecZBecZ?dd(ldmeZemfZfGd)d*eeZgGd+d,eRZhGd-d.eRZiGd/d0eRZjGd1d2ZkGd3d4e)ZlGd5d6ZmGd7d8e\ZnGd9d:eVZoe e&Gd;d<Zpe e'Gd=d>ZqGd?d@ZrGdAdBe=erZsGdCdDe=erZtGdEdFe=ZuGdGdHeZvGdIdJZwGdKdLe=ZxdS)Mz' Tests for L{twisted.conch.endpoints}. N)BytesIO)pack)IO) implementer) verifyClass verifyObject) ConchErrorHostKeyChangedUserRejectedKey) IConchUser)'InMemoryUsernamePasswordDatabaseDontUse)Portal) IPv4Address)CancelledErrorDeferredfailsucceed)ConnectingCancelledErrorConnectionDoneConnectionRefusedErrorProcessTerminated)IAddressIStreamClientEndpoint)FactoryProtocol)EventLoggingObserverMemoryReactorClockStringTransport)LogLevelglobalLogPublisher) networkString)Failure)FilePath)msg) requireModule)TestCase cryptography) ConchUser)InMemorySSHKeyDBSSHPublicKeyChecker) ConsoleUIKnownHostsFile)AuthenticationFailedSSHCommandAddressSSHCommandClientEndpoint_ExistingConnectionHelper_ISSHConnectionCreator_NewConnectionHelper)common)SSHAgentServer) SSHChannel) SSHConnection) SSHFactory)Key)SSHClientTransport)SSHUserAuthServer)privateDSA_opensshprivateRSA_openssh privateRSA_openssh_encrypted_aespublicRSA_opensshzcan't run w/o cryptography) FakeTransportconnectceZdZdZdZdZdS)AbortableFakeTransportzC A L{FakeTransport} with added C{abortConnection} support. Fcd|_dS)z} Abort the connection in a fake manner. This should really be implemented in the underlying module. TNabortedselfs `/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/twisted/conch/test/test_endpoints.pyabortConnectionz&AbortableFakeTransport.abortConnection]s  N)__name__ __module__ __qualname____doc__rErIrJrHrBrBVs4GrJrBceZdZdZdZdS)BrokenExecSessionzO L{BrokenExecSession} is a session on which exec requests always fail. cdS)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} rrOrGdatas rH request_execzBrokenExecSession.request_execk qrJNrKrLrMrNrUrOrJrHrQrQf-     rJrQceZdZdZdZdS)WorkingExecSessionzS L{WorkingExecSession} is a session on which exec requests always succeed. cdS)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} rOrSs rHrUzWorkingExecSession.request_exec}rVrJNrWrOrJrHrZrZxrXrJrZceZdZdZdZdS)UnsatisfiedExecSessionz L{UnsatisfiedExecSession} is a session on which exec requests are always delayed indefinitely, never succeeding or failing. ctS)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} )rrSs rHrUz#UnsatisfiedExecSession.request_execszzrJNrWrOrJrHr^r^s-     rJr^ceZdZdZdZdS) TrivialRealmci|_dSN) channelLookuprFs rH__init__zTrivialRealm.__init__srJcLt}|j|_t|dfS)NcdSrcrOrOrJrHz,TrivialRealm.requestAvatar..sDrJ)r(rdr )rGavatarIdmind interfacesavatars rH requestAvatarzTrivialRealm.requestAvatars%#1FLL11rJN)rKrLrMrermrOrJrHraras2   22222rJraceZdZdZdZdS)AddressSpyFactoryNc:||_tj||Src)addressr buildProtocol)rGrqs rHrrzAddressSpyFactory.buildProtocols $T7333rJ)rKrLrMrqrrrOrJrHroros(G44444rJroc eZdZdZdZdZdS)FixedResponseUIc||_dSrc)result)rGrvs rHrezFixedResponseUI.__init__s  rJc*t|jSrc)rrvrGtexts rHpromptzFixedResponseUI.promptst{###rJcdSrcrOrxs rHwarnzFixedResponseUI.warns rJN)rKrLrMrerzr|rOrJrHrtrtsA$$$     rJrtc:eZdZedZedZdS)FakeClockSSHUserAuthServerc$|jjjS)zy Use the C{attemptsBeforeDisconnect} value defined by the factory to make it easier to override. ) transportfactoryattemptsBeforeDisconnectrFs rHrz3FakeClockSSHUserAuthServer.attemptsBeforeDisconnects ~%>>rJc$|jjjS)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). )rrreactorrFs rHclockz FakeClockSSHUserAuthServer.clocks~%--rJN)rKrLrMpropertyrrrOrJrHr~r~sH ??X?..X...rJr~cHeZdZedZedZeedZdZ dS)CommandFactoryc:dtjtiSNssh-rsa)rT)r8 fromStringr>rFs rH publicKeyszCommandFactory.publicKeyssCN0ABBBCCrJc:dtjtiSr)r8rr<rFs rH privateKeyszCommandFactory.privateKeyssCN0BCCCDDrJ)s ssh-userauthsssh-connectionrN) rKrLrMrrrr~r6servicesrrOrJrHrrsf DDXDEEXE4(H !rJrceZdZdS) MemoryAddressN)rKrLrMrOrJrHrrsDrJrceZdZdZdZdZdS)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"d|_||_dS)z @param server: An L{IProtocol} provider to which the client will be connected. @type server: L{IProtocol} provider N)pump_server)rGservers rHrez SingleUseMemoryEndpoint.__init__s   rJc J|jtd |t}t |jt |jd|t |d|_t|S#t$rtcYSwxYw)Nz(SingleUseMemoryEndpoint was already usedTisServerF) r Exceptionrrrr@rrBr BaseExceptionr)rGrprotocols rHr@zSingleUseMemoryEndpoint.connects 9 FGG G %,,]__==H  &t|dCCC&x%@@@ DI 8$$ $   66MMM s!BB"!B"N)rKrLrMrNrer@rOrJrHrrs<%%%%%rJrceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZddZdZdZdS)"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}. cd|_d|_d|_d|_t |_t |_t|j|_ t|_ |j |j|j|j |j t|_|j|j_|j |j_ |j||jjt'ddd|_t'ddd |_dS) Nsssh.example.comi&suserspasswordTCPz10.0.0.1i90z192.168.100.200i1)hostnameportuserpasswordrrrarealmrportalr passwdDBaddUserregisterCheckerrrdoStart addCleanupdoStopr clientAddress serverAddressrFs rHsetUpz(SSHCommandClientEndpointTestsMixin.setUps*   # )++ !^^ TZ(( ?AA  di777 ##DM222%'' #| "k    +,,,( EBB(0A5IIrJc:t|jjd)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 createNotImplementedError __class__rKrFs rHcreatez)SSHCommandClientEndpointTestsMixin.create1s' "~& C C C   rJc:t|jjd)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- did not implement assertClientTransportStaterrGclientimmediateCloses rHassertClientTransportStatez=SSHCommandClientEndpointTestsMixin.assertClientTransportState:s)"~&&& )   rJc:t|jjd)z Do any remaining work necessary to complete an in-memory connection attempted initiated using C{self.reactor}. z# did not implement finishConnectionrrFs rHfinishConnectionz3SSHCommandClientEndpointTestsMixin.finishConnectionJs' "~& M M M   rJc|d}|d}t|d|j|j}t|d|j|j}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)rrrBrrr@)rG serverFactory clientFactoryclientProtocolserverProtocolclientTransportserverTransportrs rHconnectedServerAndClientz;SSHCommandClientEndpointTestsMixin.connectedServerAndClientSs'44T::&44T::0 **     1 **    ~XX~t33rJcp|}t}t|_||}|\}}}|t}|d|dj j |dj j f| dt|| |}|t| d|j j ||ddS)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 channelrr\unknown channelFN)rrrrr@rflushLoggedErrorsr assertInvaluerT assertEquallenfailureResultOftrapr) rGendpointr connectedrrrerrorsfs rHtest_channelOpenFailurez:SSHCommandClientEndpointTestsMixin.test_channelOpenFailureps ;;==))#$$W-- #4466'' 33 '&)/*>q @U)VWWW CKK(((   + + z +QW];;; ''66666rJct|jjd<|}t }t |_||}|\}}}| |}| t| d|j j ||ddS)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)rQrrdrrrrr@rrrr rrrrGrrrrrrrs rHtest_execFailurez3SSHCommandClientEndpointTestsMixin.test_execFailures 0A  ,;;==))#$$W-- #4466   + + z 117=AAA ''66666rJct|jjd<|}t }t |_||}|\}}}| | |}| t| |ddS)z If execution of the command is cancelled via the L{Deferred} returned by L{SSHCommandClientEndpoint.connect}, the connection is closed immediately. rTN)r^rrdrrrrr@rcancelrrrrrs rHtest_execCancelledz5SSHCommandClientEndpointTestsMixin.test_execCancelleds 0F  ,;;==))#$$W-- #4466   + + ~ ''55555rJct|jjd<|}t }t |_|||\}}}| |j t| |j |j j| |j|j j| d|j jdS)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)rZrrdrrorrr@rassertIsInstancerqr.rrgetHostrrusernamecommand)rGrrrrrs rHtest_buildProtocolz5SSHCommandClientEndpointTestsMixin.test_buildProtocols0B  ,;;==#%%#!!!#4466 go/@AAA )1133W_5KLLL GO$<=== (?@@@@@rJcBt|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. rN) rZrrdrrrrr@rsuccessResultOfassertIsNotNonerrGrrrrrrrs rHtest_makeConnectionz6SSHCommandClientEndpointTestsMixin.test_makeConnections0B  ,;;==))#$$W-- #4466'' 22 X/00000rJct|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, worldrJN)rZrrdrrrrr@rrappend dataReceivedridservicechannelswriterrjoin) rGrrrrrrrr channelIds rHtest_dataReceivedz4SSHCommandClientEndpointTestsMixin.test_dataReceiveds 0B  ,;;==))#$$W-- #4466'' 22 , 3&)  *00AAA  #((<*@*@AAAAArJct|jjd<|}t }t |_||}|\}}}| |}g}|j |_ |j j } |jj| ||dt&||ddS)zq When the command closes the channel, the protocol's C{connectionLost} method is called. rrFN)rZrrdrrrrr@rrrconnectionLostrrrrloseConnectionrrrr) rGrrrrrrrrrs rHtest_connectionLostz6SSHCommandClientEndpointTestsMixin.test_connectionLosts 0B  ,;;==))#$$W-- #4466'' 22"0"7&)  *99;;; q~... ''66666rJc&t|jjd<|}t }t |_||}|\}}}| |} g} | j | _ | j j } |jj| } |j| ||| |||d| dS)zJ Test handling of non-zero exit statuses or exit signals. rFr)rZrrdrrrrr@rrrrrrrr sendRequestrrr) rGrequest requestArgrrrrrrrrrchannels rH_exitStatusTestz2SSHCommandClientEndpointTestsMixin._exitStatusTests0B  ,;;==))#$$W-- #4466'' 22"0"7 &) .))4""7GZ@@@     ''666a  rJcd}|dtd|}|tdS) 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)rrrr)rGexitCodeexcs rHtest_zeroExitCodez4SSHCommandClientEndpointTestsMixin.test_zeroExitCode2s@ "">4h3G3GHH      rJc d}d}|dtd|}|t|||jj|||jjdS)r{Nrr)rrrrrrrsignal)rGrrrs rHtest_nonZeroExitStatusz9SSHCommandClientEndpointTestsMixin.test_nonZeroExitStatus<s| "">4h3G3GHH "### 39#5666 !122222rJct}tj||tj|d}d}dt jddt jdt jdg}|d|}| t| ||j j | ||j jd }tj|tjtjtjt(j|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. NrJsTERMsmessagesen-USs exit-signalz'twisted.conch.endpoints._CommandChannelTmessage) log_level log_namespaceshortSignalName coreDumped errorMessage languageTag)rr addObserverrremoveObserverrr3NSrrrrrrrhamcrest assert_thathas_item has_entriesequal_torinfo)rG logObserverrrpacketr logNamespaces rHtest_nonZeroExitSignalz9SSHCommandClientEndpointTestsMixin.test_nonZeroExitSignalIsT+,, &{333 *9;GGG '"" *%% (##    "">6:: "### 39#5666 !1222@    $%-%6x}%E%E)5+2&*(1'/          rJFc|jj}g|rfd}nj}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.dSrc)r)recordersrHrhz;SSHCommandClientEndpointTestsMixin.record..s--rJ)rrrsetattrrr)rGrreventnoArgsrrr#s @rHrecordz)SSHCommandClientEndpointTestsMixin.recordwsU &)   ----AAA' 2E1===rJct|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. rrrrJN)rZrrdrrrrr@rrr'rrrrr rGrrrrrrrrs rH test_writez-SSHCommandClientEndpointTestsMixin.test_writes 0B  ,;;==))#$$W-- #4466'' 22{{68^DD   111  #((<*@*@AAAAArJct|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. rrrrJN)rZrrdrrrrr@rrr'r writeSequencerrrr)s rHtest_writeSequencez5SSHCommandClientEndpointTestsMixin.test_writeSequences 0B  ,;;==))#$$W-- #4466'' 22{{68^DD ((/):;;;  #((<*@*@AAAAArJN)F)rKrLrMrNrrrrrrrrrrrrrrr r r'r*r-rOrJrHrrsR  JJJ(         444:7774777*666*AAA.111&BBB67778!!!:!!! 3 3 3, , , \6BBB*BBBBBrJrceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZdZdS)NewConnectionTestsz` Tests for L{SSHCommandClientEndpoint} when using the C{newConnection} constructor. ct|t||_t |j|_|j|j|j j d|jt|j j |j j d|jdS) Configure an SSH server with password authentication enabled for a well-known (to the tests) account. rN)rrr#mktemp hostKeyPathr, knownHosts addHostKeyrrrr!rhostsaverFs rHrzNewConnectionTests.setUps +00666#DKKMM22()9:: ""4=$,2I*2UVVV "" $,1 2 2DL4KJ4W    rJc tj|jd|j|j|j|j|jtdS)zu Create and return a new L{SSHCommandClientEndpoint} using the C{newConnection} constructor. rFrr4ui) r/ newConnectionrrrrrr4rtrFs rHrzNewConnectionTests.createsJ (5 L  I M I]u%%    rJcd||j|jjddS)z} Establish the first attempted TCP connection using the SSH server which C{self.factory} can create. r)rrr tcpClientsrFs rHrz#NewConnectionTests.finishConnections2 ,, L$,1!4Q7   rJc|||dd}|j||dg|||jdS)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'rrrrreportDisconnect)rGrrrrr@s rHloseConnectionToServerz)NewConnectionTests.loseConnectionToServers*VXxEE))+++  $(((  ))+++++rJc|r!||jjdS||jjdS)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) assertTruerrE disconnectingrs rHrz-NewConnectionTests.assertClientTransportStatesH  < OOF,4 5 5 5 5 5 OOF,: ; ; ; ; ;rJctj|jdd|j|j}|t t|dS)zY L{SSHCommandClientEndpoint} instances provide L{IStreamClientEndpoint}. dummy command dummy userN)r/r;rrrrDrrrGrs rHtest_interfacez!NewConnectionTests.test_interfacesM,9 L*M4=$)    %:HEEFFFFFrJctj|jdd|j}|d|jjdS)z L{SSHCommandClientEndpoint} uses the default port number for SSH when the C{port} argument is not specified. rGrHNr/r;rrr_creatorrrIs rHtest_defaultPortz#NewConnectionTests.test_defaultPort$sH ,9 L*M4=   X.344444rJctj|jdd|jd}|d|jjdS)zU L{SSHCommandClientEndpoint} uses the C{port} argument if specified. rGrHi)rNrMrIs rHtest_specifiedPortz%NewConnectionTests.test_specifiedPort.sO,9 L*M4=t    x0566666rJc tj|jd|j|j|j|j|jtd}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. rFr9rr\N)r/r;rrrrrr4rtrrrr@r>rr!r)rGrrr6rtimeout bindAddresss rHtest_destinationz#NewConnectionTests.test_destination7s ,9 L  I M I]u%%    ))#!!!48L4KA4N1dGWk  d(;(;<<< D))) C 78899999rJc tj|jdd|j|j|jt d}t}t|_ | |}|jj dd}| dtt||tdS)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. rrHFr4r:rr=N)r/r;rrrr4rtrrrr@r>clientConnectionFailedr"rrrrGrrds rHtest_connectionFailedz(NewConnectionTests.test_connectionFailedOs ,9 L   M Iu%%   ))#   W % %,)!,Q/&&tW5K5M5M-N-NOOO Q$$%;<<<<rrr rs rHtest_userRejectedHostKeyz+NewConnectionTests.test_userRejectedHostKeygs,9 L   M I%dkkmm44u%%   ))#$$W-- #<< L$,1!4Q7     + + rJc <tjt}t t |}|t|j j |tjtd}||j |td}tj|jdd|j |jd||}t%}t&|_||}||j|jjdd \}} } ||} | t6d 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}. stestxp) passphraseTrrHdummy passwordr9rr=N)r8rr<publicr,r#r2r5r!rr6r=rrtr/r;rrrrrr@rrr>rrr ) rGfirstKeyr4 differentKeyr:rrrrrrrs rHtest_mismatchedHostKeyz)NewConnectionTests.test_mismatchedHostKeysk>"455<<>>#HT[[]]$;$;<< mD,>,CDDhOOO~ ,   &((  dm\::: T " "+9 L   M I&!    ))#$$W-- #<< L$,1!4Q7     + + ~rJc 2tj|jdd|j|j|jt d}t}t|_ | |}t}|jj dd}| d}|||t!t#||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. rrHFrWrr=N)r/r;rrrr4rtrrrr@rr>rrmakeConnectionrr"rrrrGrrrZrrs rH!test_connectionClosedBeforeSecurez4NewConnectionTests.test_connectionClosedBeforeSecures,9 L   M Iu%%   ))#   W % %#%% ,)!,Q/&&t,,i(((gn&6&677888 Q$$^44444rJc tj|jdd|j|j|jt d}t}t|_ | |}tdd}|jj dd}| d}|||||t$||j|t-t/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. rrHFrWNrrr=)r/r;rrrr4rtrrrr@rBr>rrrfrrrrrDrErr"rrgs rH$test_connectionCancelledBeforeSecurez7NewConnectionTests.test_connectionCancelledBeforeSecures!,9 L   M Iu%%   ))#   W % %*4%@@@ ,)!,Q/&&t,,i(((   Q$$^444  )*** gn&6&67788888rJc tj|jdd|j|j|jt d}t}t|_ | |}| | | t||jjdjdS)zz If the connection is cancelled before it finishes connecting, the connection attempt is stopped. rrHFrWrN)r/r;rrrr4rtrrrr@rrrrrD connectorsstoppedConnectingrYs rH'test_connectionCancelledBeforeConnectedz:NewConnectionTests.test_connectionCancelledBeforeConnecteds ,9 L   M Iu%%   ))#   W % %   Q$$%=>>>  /2DEEEEErJc Btj|jdd|j|jd|jt d}t}t|_ | |}| |j |jj dd\}}}|j|jj|||}|t(||ddS) 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}. rrHr`Fr9rr=N)r/r;rrrr4rtrrrr@rrr>advancer passwordDelayflushrrr-rrs rH"test_passwordAuthenticationFailurez5NewConnectionTests.test_passwordAuthenticationFailures  ,9 L   M I&u%%    ))#$$W-- #<< L$,1!4Q7   V^9:::   + + #$$$ ''66666rJcd|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} cdi|]-\}}|tj|g.SrO)r8rra).0kvs rH z6NewConnectionTests.setupKeyChecker..:s7MMMtq!1s~a((//112MMMrJN)itemsr*r)r)rGrusersmappingcheckers rHsetupKeyCheckerz"NewConnectionTests.setupKeyChecker-sPNMu{{}}MMM%&6w&?&?@@w'''''rJc ptjt}||j|jt itj|j d|j|j |j |g|j td}t}t|_||}||j|j jdd\}}}||}|t.||jjdS)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}. rFkeysr4r:rr=N)r8rr<r~rrr;r/r;rrrr4rtrrrr@rrr>rrr-rDrrE) rGbadKeyrrrrrrrs rH#test_publicKeyAuthenticationFailurez6NewConnectionTests.test_publicKeyAuthenticationFailure>s  233 T[496H*IJJJ+9 L  I M Iu%%    ))#$$W-- #<< L$,1!4Q7     + + #$$$ (677777rJc tjt}||j|jt itj|j d|j|j |j |g|j |j td }t}t |_||}|jxjdz c_||j|j jdd\}}}||t2}|d|djj|djjf|dt=|||} | t2|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. rF)rrr4r:r\rr=rrN)$r8rr<r~rrr;r/r;rrrrr4rtrrrr@rrrr>rrr rrrTrrrrrDrrE) rGrrrrrrrrrs rHtest_authenticationFallbackz.NewConnectionTests.test_authenticationFallbackcs  233 T[496H*IJJJ+9 L  I M I]u%%    ))#$$W--  --2--#<< L$,1!4Q7   '' 33 '&)/*>q @U)VWWW CKK(((   + + z +QW];;; (677777rJc Ztjt}||j|jtit |jjd<tj |j d|j|j |j |g|jtd}t!}t"|_||}||j|j jdd\}}}||}||jdS)z If L{SSHCommandClientEndpoint} is initialized with any private keys, it will try to use them to authenticate with the SSH server. rrFrrr=N)r8rr;r~rrrZrrdr/r;rrrr4rtrrrr@rrr>rrr) rGkeyrrrrrrrs rHtest_publicKeyAuthenticationz/NewConnectionTests.test_publicKeyAuthentications n/00 T[496H*IJJJ/A  ,+9 L  I M Iu%%    ))#$$W-- #<< L$,1!4Q7  '' 22 X/00000rJc tj|jd|j|j|j|jtd}t}t|_ | |}| |j |jjdd\}}}|||}|t$||jjdS)z If the password is not specified, L{SSHCommandClientEndpoint} doesn't try it as an authentication mechanism. rFrWrr=N)r/r;rrrrr4rtrrrr@rrr>rrrr-rDrrErs rHtest_skipPasswordAuthenticationz2NewConnectionTests.test_skipPasswordAuthentications ,9 L  I M Iu%%   ))#$$W-- #<< L$,1!4Q7      + + #$$$ (677777rJc 0tjt}t}t |_||dfi|j_||j |j tit|}tj |jd|j |j|j|jt%d|}t&|jjd<t }t,|_||}||j|jjdd\}}} t7dD]/} |j| 0||} || j| ||| | |!|jj"|!|jj#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. rJrF)r4r: agentEndpointrrr=N)$r8rr<r4rrblobrr~rrrr/r;rrrr4rtrZrrdrrr@rr>rangerrrrrBrDrEclientIO) rGr agentServerrrrrrrrirs rHtest_agentAuthenticationz+NewConnectionTests.test_agentAuthenticationsn/00$&& %ii $'HHJJc #;   T[496H*IJJJ/ << +9 L  I M Iu%%'    0B  ,))#$$W-- #<< L$,1!4Q7   r  A   # # % % % IIKKKK'' 22 X/000 ##FFHdCCC (6777  *3ABBBBBrJc|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. rN)rZrrdrrrrr@rrrBrDrrErs rHtest_loseConnectionz&NewConnectionTests.test_loseConnections 0B  ,;;==))#$$W-- #4466'' 22 ##FFHdCCC (677777rJN)rKrLrMrNrrrrBrrJrOrQrUr[r]rdrhrjrnrsr~rrrrrrrOrJrHr/r/s         !,!,!,F < < <GGG555777:::0===0   8***X555< 9 9 9DFFF,&7&7&7P((("#8#8#8J.8.8.8`111>888B1C1C1Cf88888rJr/c*eZdZdZdZdZdZdZdS)ExistingConnectionTestsze Tests for L{SSHCommandClientEndpoint} when using the C{existingConnection} constructor. c t|tt|}||j|jjd|t|j j |jjdtj |jd|j|j|j|j|t%d|_dS)r1rrFr9N)rrr,r#r2r5rrrr!rr6r/r;rrrrrtr)rGr4s rHrzExistingConnectionTests.setUp#s +00666#HT[[]]$;$;<< dmT\-DZ-PQQQ $,1 2 2DL4KJ4W   1> L  I M I]!u%%     rJct}t|_|j|}|jj} t|jjd<| |j |j j dd\}}}|jj |jj|nB#|jj |jj|wxYw||_||_||_||}|jj}t+j|dS)zz Create and return a new L{SSHCommandClientEndpoint} using the C{existingConnection} constructor. rrr=r)rrrrr@rrdcopyrZrrrr>clearupdater_client_pumprrconnr/existingConnection) rGrrrdrrrr connections rHrzExistingConnectionTests.create;s< ))#M))'22  05577  ;3EDJ $Z 0#'#@#@ dl5a8;$$ FFD J $ * * , , , J $ + +M : : : : J $ * * , , , J $ + +M : : : :   '' 22', '::}UUUs A C?Dc|j|j|j|j|j|j|jfS)z Give back the connection established in L{create} over which the new command channel being tested will exchange data. )rrrrrFs rHrz(ExistingConnectionTests.finishConnectionYs_    |T\4:55rJc||jj||jjdS)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) assertFalserrErErs rHrz2ExistingConnectionTests.assertClientTransportStategs> )7888 )122222rJN)rKrLrMrNrrrrrOrJrHrrs]    0VVV< 6 6 633333rJrc*eZdZdZdZdZdZdZdS)ExistingConnectionHelperTestsz1 Tests for L{_ExistingConnectionHelper}. c`|tttdS)zT L{_ExistingConnectionHelper} implements L{_ISSHConnectionCreator}. N)rDrr1r0rFs rHrJz,ExistingConnectionHelperTests.test_interfacews(  $:eZdZdZdeddfdZdedeefdZdS)_PTYPathzk A L{FilePath}-like object which can be opened to create a L{_ReadFile} with certain contents. contentsrNc||_dS)zz @param contents: L{bytes} which will be the contents of the L{_ReadFile} this path can open. N)r)rGrs rHrez_PTYPath.__init__s ! rJmodec:|dksJt|jS)z If the mode is r+, return a file with the given contents as a line. @return: a buffer of the given contents, which will discard any writes given to it. zr+)rr)rGrs rHopenz _PTYPath.opens!t||||t}---rJ) rKrLrMrNbytesrestrrrrOrJrHrrsf !!4!!!!..E......rJrcNeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d S) NewConnectionHelperTestsz, Tests for L{_NewConnectionHelper}. c`|tttdS)zO L{_NewConnectionHelper} implements L{_ISSHConnectionCreator}. N)rDrr1r2rFs rHrJz'NewConnectionHelperTests.test_interfaces(  $:.sFrJN)rpatchr2rr4)rGrrvs @rHtest_defaultKnownHostsz/NewConnectionHelperTests.test_defaultKnownHostssr  '8J8J8J8JKKK% $dD$dD$   ff/00000rJcbtjd}t|}t |}|d||td|jtj d}|j |d}| td|td|tj}||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. rs 127.0.0.1zCreated known_hosts file at z~/rzPatched _KNOWN_HOSTS with N)rrr#r2r,r5r7r$pathos expanduserreplacerr2rrD hasHostKey)rGrrr4homedefaultloadeds rHtest_readExistingz*NewConnectionHelperTests.test_readExistings  )*5 &&#D)) lC000 849 8 8999w!!$'')##D$// 'AAA 4 4 4555%133 )),<<=====rJc vtdddddddddd }||jtdS)zz If L{None} is passed for the C{ui} parameter to L{_NewConnectionHelper}, a L{ConsoleUI} is used. N)r2rr:r+rs rHtest_defaultConsoleUIz.NewConnectionHelperTests.test_defaultConsoleUIsH & $dD$dD$   fi33333rJc td}tdddddddddd| }||jd}||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. syesNsdoes this work?)rr2rr:rzrDrGttyrrvs rHtest_ttyConsoleUIz*NewConnectionHelperTests.test_ttyConsoleUIsu v% $dD$dD$  %%fi&6&67I&J&JKK rJc t|}tdddddddddd| }||jd}||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. Nsdid this break?)r#r2r2rr:rzrrs rH test_nottyUIz%NewConnectionHelperTests.test_nottyUI s t{{}}%%% $dD$dD$  %%fi&6&67I&J&JKK      rJc tdddddddddd }|td|jdS)zy If not passed the name of a tty in the filesystem, L{_NewConnectionHelper} uses C{b"/dev/tty"}. Ns/dev/tty)r2rr#rrs rHtest_defaultTTYFilenamez0NewConnectionHelperTests.test_defaultTTYFilenamesP & $dD$dD$   +.. ;;;;;rJc tdddddddddd }t}t|_||d||jjdS)z L{_NewConnectionHelper.cleanupConnection} closes the transport cleanly if called with C{immediate} set to C{False}. NF)r2r6rrrrDrE)rGrrs rHrz=NewConnectionHelperTests.test_cleanupConnectionNotImmediately#su & $dD$dD$  #__ .00   U333  ,:;;;;;rJc .Gdd}tdddddddddd }t}t|_||j_||d||jjjdS)z L{_NewConnectionHelper.cleanupConnection} closes the transport with C{abortConnection} if called with C{immediate} set to C{True}. ceZdZdZdZdS)MNewConnectionHelperTests.test_cleanupConnectionImmediately..AbortableFcd|_dS)z7 Abort the connection. TNrDrFs rHrIz]NewConnectionHelperTests.test_cleanupConnectionImmediately..Abortable.abortConnection9s $ rJN)rKrLrMrErIrOrJrH Abortabler6s(G $ $ $ $ $rJrNT)r2r6r9rrrDrE)rGrrrs rHrz:NewConnectionHelperTests.test_cleanupConnectionImmediately0s  $ $ $ $ $ $ $ $& $dD$dD$  #__ 133 )2 &  T222  ,6>?????rJN)rKrLrMrNrJrrrrrrrrrrOrJrHrrsSSS RRR 1 1 1>>>.444     ! ! !<<< < < <@@@@@rJr)yrNos.pathriorstructrtypingrzope.interfacerzope.interface.verifyrrrtwisted.conch.errorr r r twisted.conch.interfacesr twisted.cred.checkersr twisted.cred.portalrtwisted.internet.addressrtwisted.internet.deferrrrrtwisted.internet.errorrrrrtwisted.internet.interfacesrrtwisted.internet.protocolrrtwisted.internet.testingrrrtwisted.loggerrr twisted.python.compatr!twisted.python.failurer"twisted.python.filepathr#twisted.python.logr$twisted.python.reflectr%twisted.trial.unittestr&twisted.conch.avatarr(twisted.conch.checkersr)r*twisted.conch.client.knownhostsr+r,twisted.conch.endpointsr-r.r/r0r1r2twisted.conch.sshr3twisted.conch.ssh.agentr4twisted.conch.ssh.channelr5twisted.conch.ssh.connectionr6twisted.conch.ssh.factoryr7twisted.conch.ssh.keysr8twisted.conch.ssh.transportr9twisted.conch.ssh.userauthr:twisted.conch.test.keydatar;r<r=r>skiprtwisted.test.iosimr?r@rBrQrZr^rarortr~rrrrr/rrrrrrOrJrHrsZ&&&&&&;;;;;;;;KKKKKKKKKK//////IIIIII&&&&&&000000JJJJJJJJJJJJ HGGGGGGG77777777 87777777//////******,,,,,,""""""000000++++++=  $......LLLLLLLLIIIIIIII)(((((666666444444::::::444444******>>>>>><<<<<< (DJM CJNN I55555555     ]     $$Z&2222222244444444        .....!2...(!!!!!Z!!!* X          "###%#%#%#%#%#%#%$##%LkBkBkBkBkBkBkBkB\ ] 8] 8] 8] 8] 8#E] 8] 8] 8@R3R3R3R3R3h(JR3R3R3j)1)1)1)1)1H)1)1)1Xg........0G@G@G@G@G@xG@G@G@G@G@rJ