o ¼>h÷Úã@sˆdZddlZddlmZddlmZddlmZddl 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*„d*eeƒZgGd+d,„d,eRƒZhGd-d.„d.eRƒZiGd/d0„d0eRƒZjGd1d2„d2ƒZkGd3d4„d4e)ƒZlGd5d6„d6ƒZmGd7d8„d8e\ƒZnGd9d:„d:eVƒZoe e&ƒGd;d<„d<ƒƒZpe e'ƒGd=d>„d>ƒƒZqGd?d@„d@ƒZrGdAdB„dBe=erƒZsGdCdD„dDe=erƒZtGdEdF„dFe=ƒZuGdGdH„dHeƒZvGdIdJ„dJƒZwGdKdL„dLe=ƒZxdS)Mz' Tests for L{twisted.conch.endpoints}. éN)ÚBytesIO)Úpack)ÚIO)Ú implementer)Ú verifyClassÚ verifyObject)Ú ConchErrorÚHostKeyChangedÚUserRejectedKey)Ú IConchUser)Ú'InMemoryUsernamePasswordDatabaseDontUse)ÚPortal)Ú IPv4Address)ÚCancelledErrorÚDeferredÚfailÚsucceed)ÚConnectingCancelledErrorÚConnectionDoneÚConnectionRefusedErrorÚProcessTerminated)ÚIAddressÚIStreamClientEndpoint)ÚFactoryÚProtocol)ÚEventLoggingObserverÚMemoryReactorClockÚStringTransport)ÚLogLevelÚglobalLogPublisher)Ú networkString)ÚFailure)ÚFilePath)Úmsg)Ú requireModule)ÚTestCaseÚ cryptography)Ú ConchUser)ÚInMemorySSHKeyDBÚSSHPublicKeyChecker)Ú ConsoleUIÚKnownHostsFile)ÚAuthenticationFailedÚSSHCommandAddressÚSSHCommandClientEndpointÚ_ExistingConnectionHelperÚ_ISSHConnectionCreatorÚ_NewConnectionHelper)Úcommon)ÚSSHAgentServer)Ú SSHChannel)Ú SSHConnection)Ú SSHFactory)ÚKey)ÚSSHClientTransport)ÚSSHUserAuthServer)ÚprivateDSA_opensshÚprivateRSA_opensshÚ privateRSA_openssh_encrypted_aesÚpublicRSA_opensshzcan't run w/o cryptography)Ú FakeTransportÚconnectc@seZdZdZdZdd„ZdS)ÚAbortableFakeTransportzC A L{FakeTransport} with added C{abortConnection} support. FcCó d|_dS)z} Abort the connection in a fake manner. This should really be implemented in the underlying module. TN©Úaborted©Úself©rFú/var/www/vedio/testing/chatpythonscript.ninositsolution.com/env/lib/python3.10/site-packages/twisted/conch/test/test_endpoints.pyÚabortConnection]ó z&AbortableFakeTransport.abortConnectionN)Ú__name__Ú __module__Ú __qualname__Ú__doc__rCrHrFrFrFrGr@Vs r@c@óeZdZdZdd„ZdS)ÚBrokenExecSessionzO L{BrokenExecSession} is a session on which exec requests always fail. cCó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} rrF©rEÚdatarFrFrGÚ request_execkó zBrokenExecSession.request_execN©rJrKrLrMrSrFrFrFrGrOfó rOc@rN)ÚWorkingExecSessionzS L{WorkingExecSession} is a session on which exec requests always succeed. cCrP)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} érFrQrFrFrGrS}rTzWorkingExecSession.request_execNrUrFrFrFrGrWxrVrWc@rN)ÚUnsatisfiedExecSessionz‰ L{UnsatisfiedExecSession} is a session on which exec requests are always delayed indefinitely, never succeeding or failing. cCstƒ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} )rrQrFrFrGrSs z#UnsatisfiedExecSession.request_execNrUrFrFrFrGrYŠs rYc@seZdZdd„Zdd„ZdS)Ú TrivialRealmcCs i|_dS©N)Ú channelLookuprDrFrFrGÚ__init__žó zTrivialRealm.__init__cGstƒ}|j|_t|dd„fS)NcSódSr[rFrFrFrFrGÚ¤óz,TrivialRealm.requestAvatar..)r'r\r )rEÚavatarIdÚmindÚ interfacesÚavatarrFrFrGÚ requestAvatar¡szTrivialRealm.requestAvatarN)rJrKrLr]rfrFrFrFrGrZs rZc@seZdZdZdd„ZdS)ÚAddressSpyFactoryNcCs||_t ||¡Sr[)ÚaddressrÚ buildProtocol)rErhrFrFrGriªs zAddressSpyFactory.buildProtocol)rJrKrLrhrirFrFrFrGrg§ó rgc@s$eZdZdd„Zdd„Zdd„ZdS)ÚFixedResponseUIcCs ||_dSr[©Úresult)rErmrFrFrGr]°r^zFixedResponseUI.__init__cCs t|jƒSr[)rrm©rEÚtextrFrFrGÚprompt³r^zFixedResponseUI.promptcCr_r[rFrnrFrFrGÚwarn¶szFixedResponseUI.warnN)rJrKrLr]rprqrFrFrFrGrk¯s rkc@s$eZdZedd„ƒZedd„ƒZdS)ÚFakeClockSSHUserAuthServercCó |jjjS)zy Use the C{attemptsBeforeDisconnect} value defined by the factory to make it easier to override. )Ú transportÚfactoryÚattemptsBeforeDisconnectrDrFrFrGrv¼rIz3FakeClockSSHUserAuthServer.attemptsBeforeDisconnectcCrs)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). )rtruÚreactorrDrFrFrGÚclockÄs z FakeClockSSHUserAuthServer.clockN)rJrKrLÚpropertyrvrxrFrFrFrGrrºs  rrc@s2eZdZedd„ƒZedd„ƒZeedœZdZ dS)ÚCommandFactorycCódtjtdiS©Nóssh-rsa)rR)r7Ú fromStringr=rDrFrFrGÚ publicKeysÏózCommandFactory.publicKeyscCr{r|)r7r~r;rDrFrFrGÚ privateKeysÓr€zCommandFactory.privateKeys)s ssh-userauthsssh-connectionrN) rJrKrLryrrrrr5ÚservicesrvrFrFrFrGrzÎs  þ rzc@s eZdZdS)Ú MemoryAddressN)rJrKrLrFrFrFrGrƒãsrƒc@s eZdZdZdd„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} cCsd|_||_dS)z˜ @param server: An L{IProtocol} provider to which the client will be connected. @type server: L{IProtocol} provider N)ÚpumpÚ_server)rEÚserverrFrFrGr]ôs z SingleUseMemoryEndpoint.__init__cCsh|jdur tdƒ‚z| tƒ¡}Wn tytƒYSwt|jt|jdd|t|ddƒ|_t |ƒS)Nz(SingleUseMemoryEndpoint was already usedT©ÚisServerF) r…Ú ExceptionrirƒÚ BaseExceptionrr?r†r@r)rEruÚprotocolrFrFrGr?ýs   ÿ  üzSingleUseMemoryEndpoint.connectN)rJrKrLrMr]r?rFrFrFrGr„ès r„c@sªeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„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}. cCs°d|_d|_d|_d|_tƒ|_tƒ|_t|jƒ|_ t ƒ|_ |j   |j|j¡|j   |j ¡tƒ|_|j|j_|j |j_ |j ¡| |jj¡tdddƒ|_tddd ƒ|_dS) Nsssh.example.comi&¤suserspasswordÚTCPz10.0.0.1i90z192.168.100.200i1Ô)ÚhostnameÚportÚuserÚpasswordrrwrZÚrealmr Úportalr ÚpasswdDBÚaddUserÚregisterCheckerrzruÚdoStartÚ addCleanupÚdoStoprÚ clientAddressÚ serverAddressrDrFrFrGÚsetUps"    z(SSHCommandClientEndpointTestsMixin.setUpcCó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__rJrDrFrFrGÚcreate1ó ÿz)SSHCommandClientEndpointTestsMixin.createcCstd|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ÚimmediateCloserFrFrGÚassertClientTransportState:s  ÿÿz=SSHCommandClientEndpointTestsMixin.assertClientTransportStatecCrž)zˆ Do any remaining work necessary to complete an in-memory connection attempted initiated using C{self.reactor}. z# did not implement finishConnectionrŸrDrFrFrGÚfinishConnectionJr£z3SSHCommandClientEndpointTestsMixin.finishConnectioncCsT| 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)rir@r›rœr?)rEÚ serverFactoryÚ clientFactoryÚclientProtocolÚserverProtocolÚclientTransportÚserverTransportr…rFrFrGÚconnectedServerAndClientSs üü z;SSHCommandClientEndpointTestsMixin.connectedServerAndClientc Csš| ¡}tƒ}t|_| |¡}| ¡\}}}| t¡}| d|dj j |dj 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 channelrrXóunknown channelFN)r¢rrrŒr?r¨ÚflushLoggedErrorsrÚassertInÚvaluerRÚ assertEqualÚlenÚfailureResultOfÚtrapr§) rEÚendpointruÚ connectedr‡r¥r…ÚerrorsÚfrFrFrGÚtest_channelOpenFailureps     z:SSHCommandClientEndpointTestsMixin.test_channelOpenFailurecCslt|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)rOr“r\r¢rrrŒr?r¨r¹rºrr·r¶r§©rEr»rur¼r‡r¥r…r¾rFrFrGÚtest_execFailureŠs    z3SSHCommandClientEndpointTestsMixin.test_execFailurecCsdt|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)rYr“r\r¢rrrŒr?r¨Úcancelr¹rºrr§rÁrFrFrGÚtest_execCancelledŸs    z5SSHCommandClientEndpointTestsMixin.test_execCancelledcCs‚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)rWr“r\r¢rgrrŒr?r¨ÚassertIsInstancerhr-r·rtÚgetHostr‡r‘ÚusernameÚcommand)rEr»rur‡r¥r…rFrFrGÚtest_buildProtocol´s  z5SSHCommandClientEndpointTestsMixin.test_buildProtocolcCsRt|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) rWr“r\r¢rrrŒr?r¨ÚsuccessResultOfÚassertIsNotNonert©rEr»rur¼r‡r¥r…rŒrFrFrGÚtest_makeConnectionËs   z6SSHCommandClientEndpointTestsMixin.test_makeConnectionc Cs†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)rWr“r\r¢rrrŒr?r¨rËÚappendÚ dataReceivedrtÚidÚserviceÚchannelsÚwriter…r·Újoin) rEr»rur¼r‡r¥r…rŒrÒÚ channelIdrFrFrGÚtest_dataReceivedÞs   z4SSHCommandClientEndpointTestsMixin.test_dataReceivedc CsŒ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ÀrFN)rWr“r\r¢rrrŒr?r¨rËrÑÚconnectionLostrtrÓrÔrÕÚloseConnectionr…rºrr§) rEr»rur¼r‡r¥r…rŒrÚrØrFrFrGÚtest_connectionLostùs   z6SSHCommandClientEndpointTestsMixin.test_connectionLostc Cs–t|jjd<| ¡}tƒ}t|_| |¡}| ¡\}}}|  |¡} g} | j | _ | j j } |jj| } |j | ||¡|  ¡| ¡| |d¡| dS)zJ Test handling of non-zero exit statuses or exit signals. rÀFr)rWr“r\r¢rrrŒr?r¨rËrÑrÚrtrÓrÔrÕÚ sendRequestrÛr…r§) rEÚrequestÚ requestArgr»rur¼r‡r¥r…rŒrÚrØÚchannelrFrFrGÚ_exitStatusTests     z2SSHCommandClientEndpointTestsMixin._exitStatusTestcCs$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árrºr)rEÚexitCodeÚexcrFrFrGÚtest_zeroExitCode2sz4SSHCommandClientEndpointTestsMixin.test_zeroExitCodecCsHd}d}| dtd|ƒ¡}| t¡| ||jj¡| ||jj¡dS)râé{Nrãrä)rárrºrr·r¶råÚsignal)rErårérærFrFrGÚtest_nonZeroExitStatus<s  z9SSHCommandClientEndpointTestsMixin.test_nonZeroExitStatuscCs¶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ÐsTERMósmessagesen-USs exit-signalz'twisted.conch.endpoints._CommandChannelTÚmessage)Ú log_levelÚ log_namespaceÚshortSignalNameÚ coreDumpedÚ errorMessageÚ languageTag)rrÚ addObserverr™ÚremoveObserverr×r2ÚNSrárºrr·r¶råréÚhamcrestÚ assert_thatÚhas_itemÚ has_entriesÚequal_torÚinfo)rEÚ logObserverråréÚpacketræÚ logNamespacerFrFrGÚtest_nonZeroExitSignalIs> ûÿ  úÿÿþz9SSHCommandClientEndpointTestsMixin.test_nonZeroExitSignalFcs<|jj}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: cs ˆ d¡Sr[)rÑrF©ÚrecorderrFrGr`‹s z;SSHCommandClientEndpointTestsMixin.record..)rtrÓrÑÚsetattrrÔrÕ)rEr‡rŒÚeventÚnoArgsrØr¾rFrrGÚrecordwsz)SSHCommandClientEndpointTestsMixin.recordc Cszt|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)rWr“r\r¢rrrŒr?r¨rËrrtrÖr…r·rש rEr»rur¼r‡r¥r…rŒrÒrFrFrGÚ test_write’s    z-SSHCommandClientEndpointTestsMixin.test_writec Cs|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)rWr“r\r¢rrrŒr?r¨rËrrtÚ writeSequencer…r·r×rrFrFrGÚtest_writeSequence§s   z5SSHCommandClientEndpointTestsMixin.test_writeSequenceN)F)rJrKrLrMrr¢r§r¨r±r¿rÂrÄrÊrÎrÙrÜrárçrêrrrr rFrFrFrGrs*     . rc@sÈeZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zdd„Zdd„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. cCsht |¡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)rrr"ÚmktempÚ hostKeyPathr+Ú knownHostsÚ addHostKeyrrurr rœÚhostÚsaverDrFrFrGrÃs  ÿzNewConnectionTests.setUpc Cs*tj|jd|j|j|j|j|jtdƒdS)zu Create and return a new L{SSHCommandClientEndpoint} using the C{newConnection} constructor. rÅF©r’rÚui) r.Ú newConnectionrwr‘rrr’rrkrDrFrFrGr¢ÒsøzNewConnectionTests.createcCs| |j|jjdd¡S)z} Establish the first attempted TCP connection using the SSH server which C{self.factory} can create. ré)r±rurwÚ tcpClientsrDrFrFrGr¨âsÿz#NewConnectionTests.finishConnectioncCsH|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)rN)rrtrÛr…r·ÚreportDisconnect)rEr‡r¥rŒr…rrFrFrGÚloseConnectionToServerës  z)NewConnectionTests.loseConnectionToServercCs(|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)Ú assertTruertrCÚ disconnectingr¤rFrFrGr§sz-NewConnectionTests.assertClientTransportStatecCs,t |jdd|j|j¡}| tt|ƒ¡dS)zY L{SSHCommandClientEndpoint} instances provide L{IStreamClientEndpoint}. ó dummy commandó dummy userN)r.rrwrrrrr©rEr»rFrFrGÚtest_interfacesÿz!NewConnectionTests.test_interfacecCs(t |jdd|j¡}| d|jj¡dS)z† L{SSHCommandClientEndpoint} uses the default port number for SSH when the C{port} argument is not specified. rréN©r.rrwrr·Ú_creatorrrrFrFrGÚtest_defaultPort$s ÿz#NewConnectionTests.test_defaultPortcCs,tj|jdd|jdd}| d|jj¡dS)zU L{SSHCommandClientEndpoint} uses the C{port} argument if specified. rri®)rNr"rrFrFrGÚtest_specifiedPort.sÿz%NewConnectionTests.test_specifiedPortc CsŽtj|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ÅFrrrXN)r.rrwr‘rrr’rrkrrrŒr?rr·r r¸)rEr»rurrÚtimeoutÚ bindAddressrFrFrGÚtest_destination7s"ø  z#NewConnectionTests.test_destinationc Csptj|jdd|j|j|jtdƒd}tƒ}t|_ |  |¡}|jj dd}|  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ÅrF©rrrrN)r.rrwrrrrkrrrŒr?rÚclientConnectionFailedr!rr¹rº©rEr»ruÚdrFrFrGÚtest_connectionFailedOsù  z(NewConnectionTests.test_connectionFailedc Csxtj|jdd|j|jt| ¡ƒtdƒd}tƒ}t |_ |  |¡}|  |j |jjdd¡\}}}| |¡}| 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ÅrFr)rrN)r.rrwrrr+r rkrrrŒr?r±rurr¹rºr rÁrFrFrGÚtest_userRejectedHostKeygs" ù   ÿ z+NewConnectionTests.test_userRejectedHostKeyc CsÈt t¡ ¡}tt| ¡ƒƒ}| t|j j ƒ|¡tjt dd ¡}| |j |¡t dƒ}tj|jdd|j |jd||d}tƒ}t|_| |¡}| |j|jjdd ¡\}} } | |¡} |  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}. stestxp)Ú passphraseTrÅródummy passwordrrrN)r7r~r;Úpublicr+r"r rr rœrr<rrkr.rrwrrrrŒr?r±rurr¹rºr ) rEÚfirstKeyrÚ differentKeyrr»rur¼r‡r¥r…r¾rFrFrGÚtest_mismatchedHostKeyƒs8ÿþø   ÿ z)NewConnectionTests.test_mismatchedHostKeyc Csˆtj|jdd|j|j|jtdƒd}tƒ}t|_ |  |¡}t ƒ}|jj dd}|  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ÅrFr)rrN)r.rrwrrrrkrrrŒr?rrriÚmakeConnectionrÚr!rr¹rº©rEr»rur,rtr¥rFrFrGÚ!test_connectionClosedBeforeSecure¯s$ù    z4NewConnectionTests.test_connectionClosedBeforeSecurec Cs¢tj|jdd|j|j|jtdƒd}tƒ}t|_ |  |¡}t ddd}|jj dd}|  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ÅrFr)Nrˆrr)r.rrwrrrrkrrrŒr?r@rrir5rÃr¹rºrrrCrÚr!rr6rFrFrGÚ$test_connectionCancelledBeforeSecureÍs(ù      z7NewConnectionTests.test_connectionCancelledBeforeSecurec Csjtj|jdd|j|j|jtdƒd}tƒ}t|_ |  |¡}|  ¡|  |¡  t¡| |jjdj¡dS)zz If the connection is cancelled before it finishes connecting, the connection attempt is stopped. rÅrFr)rN)r.rrwrrrrkrrrŒr?rÃr¹rºrrÚ connectorsÚstoppedConnectingr+rFrFrGÚ'test_connectionCancelledBeforeConnectedïsù  z:NewConnectionTests.test_connectionCancelledBeforeConnectedc Cs˜tj|jdd|j|jd|jtdƒd}tƒ}t|_ |  |¡}|  |j |jj dd¡\}}}|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Årr0FrrrN)r.rrwrrrrkrrrŒr?r±rurÚadvancerÔÚ passwordDelayÚflushr¹rºr,r§rÁrFrFrGÚ"test_passwordAuthenticationFailures*ø   ÿ  z5NewConnectionTests.test_passwordAuthenticationFailurecCs,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} cSs"i|] \}}|t |¡ ¡g“qSrF)r7r~r1)Ú.0ÚkÚvrFrFrGÚ :s"z6NewConnectionTests.setupKeyChecker..N)Úitemsr)r(r—)rEr”ÚusersÚmappingÚcheckerrFrFrGÚsetupKeyChecker-s z"NewConnectionTests.setupKeyCheckerc Cs¤t t¡}| |j|jti¡tj|j d|j|j |j |g|j t dƒd}tƒ}t|_| |¡}| |j|j jdd¡\}}}| |¡}| 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©ÚkeysrrrrN)r7r~r;rHr”r‘r:r.rrwrrrrkrrrŒr?r±rurr¹rºr,rrtr) rEÚbadKeyr»rur¼r‡r¥r…r¾rFrFrGÚ#test_publicKeyAuthenticationFailure>s* ø   ÿ  z6NewConnectionTests.test_publicKeyAuthenticationFailurec Cs t t¡}| |j|jti¡tj|j d|j|j |j |g|j |j tdƒd }tƒ}t|_| |¡}|jjd7_| |j|j jdd¡\}}}| ¡| t¡}| d|djj|djjf¡| 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)rJr’rrrXrrr²r³N)$r7r~r;rHr”r‘r:r.rrwrrr’rrkrrrŒr?rurvr±rr…r´rrµr¶rRr·r¸r¹rºrrtr) rErKr»rur¼r‡r¥r…r½r¾rFrFrGÚtest_authenticationFallbackcs8 ÷   ÿ    z.NewConnectionTests.test_authenticationFallbackc Cs¤t t¡}| |j|jti¡t|jjd<t j |j d|j|j |j |g|jtdƒd}tƒ}t|_| |¡}| |j|j jdd¡\}}}| |¡}| |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ÅFrIrrN)r7r~r:rHr”r‘rWr“r\r.rrwrrrrkrrrŒr?r±rurrËrÌrt) rEÚkeyr»rur¼r‡r¥r…rŒrFrFrGÚtest_publicKeyAuthentication“s*  ø   ÿ z/NewConnectionTests.test_publicKeyAuthenticationc CsŠtj|jd|j|j|j|jtdƒd}tƒ}t |_ |  |¡}|  |j |jjdd¡\}}}| ¡| |¡}| t¡| |jj¡dS)z† If the password is not specified, L{SSHCommandClientEndpoint} doesn't try it as an authentication mechanism. rÅFr)rrN)r.rrwr‘rrrrkrrrŒr?r±rurr…r¹rºr,rrtrrÁrFrFrGÚtest_skipPasswordAuthentication²s&ù   ÿ  z2NewConnectionTests.test_skipPasswordAuthenticationc Cst t¡}tƒ}tƒ|_| ¡|dfi|j_| |j |j ti¡t |ƒ}t j |jd|j |j|j|jtdƒ|d}t|jjd<tƒ}t|_| |¡}| |j|jjdd¡\}}} tdƒD] } |j ¡|  ¡q]| |¡} | | 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. rÐrÅF)rrÚ agentEndpointrÀrréN)$r7r~r;r3rruÚblobrJrHr”r‘r„r.rrwrrrrkrWr“r\rrŒr?r±rÚranger…rËrÌrtrrrÚclientIO) rErNÚ agentServerrQr»rur¼r‡r¥r…ÚirŒrFrFrGÚtest_agentAuthenticationÓs> ø   ÿ     z+NewConnectionTests.test_agentAuthenticationcCsdt|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)rWr“r\r¢rrrŒr?r¨rËrrrtrrÍrFrFrGÚtest_loseConnections   z&NewConnectionTests.test_loseConnectionN)rJrKrLrMrr¢r¨rr§r r$r%r(r-r.r4r7r8r;r?rHrLrMrOrPrXrYrFrFrFrGr ½s2 #    ,"(%0! 3r c@ó0eZdZdZdd„Zdd„Zdd„Zdd „Zd S) ÚExistingConnectionTestsze Tests for L{SSHCommandClientEndpoint} when using the C{existingConnection} constructor. c Cszt |¡tt| ¡ƒƒ}| |j|jjd¡| t |j j ƒ|jjd¡t j |jd|j|j|j|j|tdƒd|_dS)r r}rÅFrN)rrr+r"r rrrurr rœrr.rrwr‘rr’rkr»)rErrFrFrGr#s ÿ øzExistingConnectionTests.setUpc Cs¼tƒ}t|_|j |¡}|jj ¡}z%t|jjd<|  |j |j j dd¡\}}}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ÀrrrÅ)rrrŒr»r?r“r\ÚcopyrWr±rurwrÚclearÚupdater†Ú_clientÚ_pumprËrtÚconnr.ÚexistingConnection) rErur¼r\r‡r¥r…rŒÚ connectionrFrFrGr¢;s&    ÿ  ÿ  zExistingConnectionTests.createcCs8|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. )r`r…r†r_rDrFrFrGr¨Ys    z(ExistingConnectionTests.finishConnectioncCs | |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)Ú assertFalsertrrCr¤rFrFrGr§gsz2ExistingConnectionTests.assertClientTransportStateN)rJrKrLrMrr¢r¨r§rFrFrFrGr[s  r[c@rZ) ÚExistingConnectionHelperTestsz1 Tests for L{_ExistingConnectionHelper}. cCó| tttƒ¡dS)zT L{_ExistingConnectionHelper} implements L{_ISSHConnectionCreator}. N)rrr0r/rDrFrFrGr wóz,ExistingConnectionHelperTests.test_interfacecCs(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)rErmÚhelperrFrFrGÚtest_secureConnection}sz3ExistingConnectionHelperTests.test_secureConnectioncCóttƒƒ}| tƒd¡dS)z L{_ExistingConnectionHelper.cleanupConnection} does nothing to the existing connection if called with C{immediate} set to C{False}. FN©r/rhÚcleanupConnection©rErkrFrFrGÚ$test_cleanupConnectionNotImmediately‡ó zBExistingConnectionHelperTests.test_cleanupConnectionNotImmediatelycCrm)zœ L{_ExistingConnectionHelper.cleanupConnection} does nothing to the existing connection if called with C{immediate} set to C{True}. TNrnrprFrFrGÚ!test_cleanupConnectionImmediately’rrz?ExistingConnectionHelperTests.test_cleanupConnectionImmediatelyN)rJrKrLrMr rlrqrsrFrFrFrGrers  rec@seZdZdedefdd„ZdS)Ú_WriteDiscarderrRÚreturncCrP)z§ Discard writes because we are emulating a console object, where they'd go to the screen, not back into the buffer to be read like an a+ file. rrFrQrFrFrGrÖŸsz_WriteDiscarder.writeN)rJrKrLrhÚintrÖrFrFrFrGrtžsrtc@s8eZdZdZdeddfdd„Zdedeefdd „ZdS) Ú_PTYPathzk A L{FilePath}-like object which can be opened to create a L{_ReadFile} with certain contents. ÚcontentsruNcCs ||_dS)zz @param contents: L{bytes} which will be the contents of the L{_ReadFile} this path can open. N)rx)rErxrFrFrGr]­s z_PTYPath.__init__ÚmodecCs|dksJ‚t|jƒS)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+)rtrx)rEryrFrFrGÚopen´s  z _PTYPath.open) rJrKrLrMÚbytesr]ÚstrrrzrFrFrFrGrw§srwc@s`eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dS)ÚNewConnectionHelperTestsz, Tests for L{_NewConnectionHelper}. cCrf)zO L{_NewConnectionHelper} implements L{_ISSHConnectionCreator}. N)rrr0r1rDrFrFrGr Ärgz'NewConnectionHelperTests.test_interfacecCs| dtj¡dS)zK The default I{known_hosts} path is I{~/.ssh/known_hosts}. z~/.ssh/known_hostsN)r·r1Ú _KNOWN_HOSTSrDrFrFrGÚtest_defaultPathÊsz)NewConnectionHelperTests.test_defaultPathc sHtƒ‰| td‡fdd„¡tddddddddddƒ }| ˆ|j¡dS)zŒ L{_NewConnectionHelper._knownHosts} is used to create a L{KnownHostsFile} if one is not passed to the initializer. Ú _knownHostscsˆSr[rF)ÚclsrlrFrGr`ÖrazANewConnectionHelperTests.test_defaultKnownHosts..N)rhÚpatchr1rirrprFrlrGÚtest_defaultKnownHostsÐs ÿz/NewConnectionHelperTests.test_defaultKnownHostscCs˜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.1zCreated known_hosts file at z~/r~zPatched _KNOWN_HOSTS with N)rzrr"r r+rrr#ÚpathÚosÚ expanduserÚreplacer‚r1r€rÚ hasHostKey)rErNr„rÚhomeÚdefaultÚloadedrFrFrGÚtest_readExistingÞs    z*NewConnectionHelperTests.test_readExistingc Cs,tddddddddddƒ }| |jt¡dS)zz If L{None} is passed for the C{ui} parameter to L{_NewConnectionHelper}, a L{ConsoleUI} is used. N)r1rÆrr*rprFrFrGÚtest_defaultConsoleUIõsÿz.NewConnectionHelperTests.test_defaultConsoleUIc CsDtdƒ}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. syesNsdoes this work?)rwr1rËrrpr©rEÚttyrkrmrFrFrGÚtest_ttyConsoleUIÿs ÿz*NewConnectionHelperTests.test_ttyConsoleUIc CsHt| ¡ƒ}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. Nsdid this break?)r"r r1rËrrprdrŽrFrFrGÚ test_nottyUI s ÿz%NewConnectionHelperTests.test_nottyUIc Cs0tddddddddddƒ }| 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)r1r·r"rrprFrFrGÚtest_defaultTTYFilenamesÿz0NewConnectionHelperTests.test_defaultTTYFilenamec CsFtddddddddddƒ }tƒ}tƒ|_| |d¡| |jj¡dS)z L{_NewConnectionHelper.cleanupConnection} closes the transport cleanly if called with C{immediate} set to C{False}. NF)r1r5rrtrorr)rErkrcrFrFrGrq#sÿ z=NewConnectionHelperTests.test_cleanupConnectionNotImmediatelyc Cs`Gdd„dƒ}tddddddddddƒ }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..AbortableFcSrA)z7 Abort the connection. TNrBrDrFrFrGrH9s z]NewConnectionHelperTests.test_cleanupConnectionImmediately..Abortable.abortConnectionN)rJrKrLrCrHrFrFrFrGÚ Abortable6rjr“NT)r1r5r8rtrorrC)rEr“rkrcrFrFrGrs0s ÿ  z:NewConnectionHelperTests.test_cleanupConnectionImmediatelyN)rJrKrLrMr rrƒrŒrrr‘r’rqrsrFrFrFrGr}¿s    r})yrMÚos.pathr…ÚiorÚstructrÚtypingrÚzope.interfacerÚzope.interface.verifyrrr÷Útwisted.conch.errorrr r Útwisted.conch.interfacesr Útwisted.cred.checkersr Útwisted.cred.portalr Útwisted.internet.addressrÚtwisted.internet.deferrrrrÚtwisted.internet.errorrrrrÚtwisted.internet.interfacesrrÚtwisted.internet.protocolrrÚtwisted.internet.testingrrrÚtwisted.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.r/r0r1Útwisted.conch.sshr2Útwisted.conch.ssh.agentr3Útwisted.conch.ssh.channelr4Útwisted.conch.ssh.connectionr5Útwisted.conch.ssh.factoryr6Útwisted.conch.ssh.keysr7Útwisted.conch.ssh.transportr8Útwisted.conch.ssh.userauthr9Útwisted.conch.test.keydatar:r;r<r=ÚskiprhÚtwisted.test.iosimr>r?r@rOrWrYrZrgrkrrrzrƒr„rr r[rertrwr}rFrFrFrGÚsš                           &1dU,