U T‚g÷Úã@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`maZan(d'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)ÚTestCaseZ 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. FcCs d|_dS)z} Abort the connection in a fake manner. This should really be implemented in the underlying module. TN©Úaborted©Úself©rDúE/tmp/pip-unpacked-wheel-1_7di8ic/twisted/conch/test/test_endpoints.pyÚabortConnection]sz&AbortableFakeTransport.abortConnectionN)Ú__name__Ú __module__Ú __qualname__Ú__doc__rArFrDrDrDrEr?Vsr?c@seZdZdZdd„ZdS)ÚBrokenExecSessionzO L{BrokenExecSession} is a session on which exec requests always fail. cCsdS)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} rrD©rCÚdatarDrDrEÚ request_execks zBrokenExecSession.request_execN©rGrHrIrJrNrDrDrDrErKfsrKc@seZdZdZdd„ZdS)ÚWorkingExecSessionzS L{WorkingExecSession} is a session on which exec requests always succeed. cCsdS)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} érDrLrDrDrErN}s zWorkingExecSession.request_execNrOrDrDrDrErPxsrPc@seZdZdZdd„ZdS)Ú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} )rrLrDrDrErNs z#UnsatisfiedExecSession.request_execNrOrDrDrDrErRŠsrRc@seZdZdd„Zdd„ZdS)Ú TrivialRealmcCs i|_dS©N)Ú channelLookuprBrDrDrEÚ__init__žszTrivialRealm.__init__cGstƒ}|j|_t|dd„fS)NcSsdSrTrDrDrDrDrEÚ¤óz,TrivialRealm.requestAvatar..)r&rUr )rCZavatarIdZmindZ interfacesZavatarrDrDrEÚ requestAvatar¡szTrivialRealm.requestAvatarN)rGrHrIrVrYrDrDrDrErSsrSc@seZdZdZdd„ZdS)ÚAddressSpyFactoryNcCs||_t ||¡SrT)ÚaddressrÚ buildProtocol)rCr[rDrDrEr\ªszAddressSpyFactory.buildProtocol)rGrHrIr[r\rDrDrDrErZ§srZc@s$eZdZdd„Zdd„Zdd„ZdS)ÚFixedResponseUIcCs ||_dSrT©Úresult)rCr_rDrDrErV°szFixedResponseUI.__init__cCs t|jƒSrT)rr_©rCÚtextrDrDrEÚprompt³szFixedResponseUI.promptcCsdSrTrDr`rDrDrEÚwarn¶szFixedResponseUI.warnN)rGrHrIrVrbrcrDrDrDrEr]¯sr]c@s$eZdZedd„ƒZedd„ƒZdS)ÚFakeClockSSHUserAuthServercCs |jjjS)zy Use the C{attemptsBeforeDisconnect} value defined by the factory to make it easier to override. )Ú transportÚfactoryÚattemptsBeforeDisconnectrBrDrDrErg¼sz3FakeClockSSHUserAuthServer.attemptsBeforeDisconnectcCs |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). )rerfÚreactorrBrDrDrEÚclockÄsz FakeClockSSHUserAuthServer.clockN)rGrHrIÚpropertyrgrirDrDrDrErdºs rdc@s2eZdZedd„ƒZedd„ƒZeedœZdZ dS)ÚCommandFactorycCsdtjtdiS©Nóssh-rsa)rM)r6Ú fromStringr<rBrDrDrEÚ publicKeysÏszCommandFactory.publicKeyscCsdtjtdiSrl)r6rnr:rBrDrDrEÚ privateKeysÓszCommandFactory.privateKeys)s ssh-userauthsssh-connectionrN) rGrHrIrjrorprdr4ZservicesrgrDrDrDrErkÎs  þ rkc@s eZdZdS)Ú MemoryAddressN)rGrHrIrDrDrDrErqãsrqc@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)rCÚserverrDrDrErVôsz SingleUseMemoryEndpoint.__init__cCsn|jdk rtdƒ‚z| tƒ¡}Wntk r<tƒYSXt|jt|jdd|t|ddƒ|_t |ƒSdS)Nz(SingleUseMemoryEndpoint was already usedT©ÚisServerF) rsÚ Exceptionr\rqÚ BaseExceptionrr>rtr?r)rCrfÚprotocolrDrDrEr>ýs    üzSingleUseMemoryEndpoint.connectN)rGrHrIrJrVr>rDrDrDrErrès  rrc@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&¤suserspasswordZTCPz10.0.0.1i90z192.168.100.200i1Ô)ÚhostnameÚportÚuserÚpasswordrrhrSÚrealmr Úportalr ZpasswdDBZaddUserÚregisterCheckerrkrfZdoStartÚ addCleanupZdoStoprÚ clientAddressÚ serverAddressrBrDrDrEÚsetUps"    z(SSHCommandClientEndpointTestsMixin.setUpcCst|jj›dƒ‚dS)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 createN©ÚNotImplementedErrorÚ __class__rGrBrDrDrEÚcreate1s ÿz)SSHCommandClientEndpointTestsMixin.createcCstd|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‡©rCÚclientZimmediateCloserDrDrEÚassertClientTransportState:s ÿÿz=SSHCommandClientEndpointTestsMixin.assertClientTransportStatecCst|jj›dƒ‚dS)zˆ Do any remaining work necessary to complete an in-memory connection attempted initiated using C{self.reactor}. z# did not implement finishConnectionNr‡rBrDrDrEÚfinishConnectionJs ÿ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)rwZ hostAddressZ peerAddressT)r\r?r„r…r>)rCZ serverFactoryZ clientFactoryZclientProtocolZserverProtocolZclientTransportZserverTransportrsrDrDrEÚ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 channelrrQóunknown channelFN)rŠrrrzr>rŽÚflushLoggedErrorsrÚassertInÚvaluerMÚ assertEqualÚlenÚfailureResultOfÚtrapr) rCÚendpointrfÚ connectedrurŒrsÚerrorsÚfrDrDrEÚ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)rKr€rUrŠrrrzr>rŽr—r˜rr•r”r©rCr™rfršrurŒrsrœrDrDrEÚ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)rRr€rUrŠrrrzr>rŽÚcancelr—r˜rrrŸrDrDrEÚ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)rPr€rUrŠrZrrzr>rŽÚassertIsInstancer[r,r•reZgetHostrur~ÚusernameÚcommand)rCr™rfrurŒrsrDrDrEÚ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) rPr€rUrŠrrrzr>rŽÚsuccessResultOfÚassertIsNotNonere©rCr™rfršrurŒrsrzrDrDrEÚ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, worldrXN)rPr€rUrŠrrrzr>rŽr¨ÚappendÚ dataReceivedreÚidÚserviceÚchannelsÚwritersr•Újoin) rCr™rfršrurŒrsrzr®Ú channelIdrDrDrEÚ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)rPr€rUrŠrrrzr>rŽr¨r­ÚconnectionLostrer¯r°r±ÚloseConnectionrsr˜rr) rCr™rfršrurŒrsrzr¶r´rDrDrEÚ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)rPr€rUrŠrrrzr>rŽr¨r­r¶rer¯r°r±Z sendRequestr·rsr) rCÚrequestZ requestArgr™rfršrurŒrsrzr¶r´ZchannelrDrDrEÚ_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)rCÚexitCodeÚexcrDrDrEÚtest_zeroExitCode2sz4SSHCommandClientEndpointTestsMixin.test_zeroExitCodecCsHd}d}| dtd|ƒ¡}| t¡| ||jj¡| ||jj¡dS)r»é{Nr¼r½)rºrr˜rr•r”r¾Úsignal)rCr¾rÂr¿rDrDrEÚ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érXsTERMósmessagesen-USs exit-signalz'twisted.conch.endpoints._CommandChannelTÚmessage)Z log_levelZ log_namespaceZshortSignalNameZ coreDumpedZ errorMessageZ languageTag)rrZ addObserverrƒZremoveObserverr³r1ZNSrºr˜rr•r”r¾rÂÚhamcrestZ assert_thatZhas_itemZ has_entriesZequal_torÚinfo)rCZ logObserverr¾rÂÚpacketr¿Z logNamespacerDrDrEÚ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¡SrT)r­rD©ZrecorderrDrErW‹rXz;SSHCommandClientEndpointTestsMixin.record..)rer¯r­Úsetattrr°r±)rCrurzÚeventÚnoArgsr´rœrDrËrEÚ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¬rXN)rPr€rUrŠrrrzr>rŽr¨rÏrer²rsr•r³© rCr™rfršrurŒrsrzr®rDrDrEÚ 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¬rXN)rPr€rUrŠrrrzr>rŽr¨rÏreZ writeSequencersr•r³rÐrDrDrEÚtest_writeSequence§s   z5SSHCommandClientEndpointTestsMixin.test_writeSequenceN)F)rGrHrIrJr†rŠrrŽrrr r¢r§r«rµr¸rºrÀrÃrÊrÏrÑrÒrDrDrDrEr{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#„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. rmN)r{r†r"ÚmktempZ hostKeyPathr*Ú knownHostsÚ addHostKeyr|rfror r…ÚhostÚsaverBrDrDrEr†Ã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©rrÖÚui) r-Ú newConnectionrhr~r|r}rrÖr]rBrDrDrErŠÒsøzNewConnectionTests.createcCs| |j|jjdd¡S)z} Establish the first attempted TCP connection using the SSH server which C{self.factory} can create. ré)rrfrhÚ tcpClientsrBrDrDrErŽâ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)rÎN)rÏrer·rsr•ZreportDisconnect)rCrurŒrzrsrßrDrDrEÚloseConnectionToServerës  z)NewConnectionTests.loseConnectionToServercCs&|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)Ú assertTruererAÚ disconnectingr‹rDrDrErsz-NewConnectionTests.assertClientTransportStatecCs,t |jdd|j|j¡}| tt|ƒ¡dS)zY L{SSHCommandClientEndpoint} instances provide L{IStreamClientEndpoint}. ó dummy commandó dummy userN)r-rÜrhr|r}rárr©rCr™rDrDrEÚ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. rãräéN©r-rÜrhr|r•Z_creatorr}rårDrDrEÚtest_defaultPort$sÿz#NewConnectionTests.test_defaultPortcCs,tj|jdd|jdd}| d|jj¡dS)zU L{SSHCommandClientEndpoint} uses the C{port} argument if specified. rãräi®)r}NrèrårDrDrEÚ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£FrÚrrQN)r-rÜrhr~r|r}rrÖr]rrrzr>rÞr•r r–)rCr™rfrØr}ÚtimeoutZ bindAddressrDrDrEÚ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£räF©rÖrÛrrÝN)r-rÜrhr|r}rÖr]rrrzr>rÞZclientConnectionFailedr!rr—r˜©rCr™rfÚdrDrDrEÚ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£räFrírrÝN)r-rÜrhr|r}r*rÕr]rrrzr>rrfrÞr—r˜r rŸrDrDrEÚ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)Z passphraseTr£räódummy passwordrÚrrÝN)r6rnr:Úpublicr*r"rÕr×r r…rØr;r|r]r-rÜrhr}rrrzr>rrfrÞr—r˜r ) rCZfirstKeyrÖZ differentKeyrÛr™rfršrurŒrsrœrDrDrEÚ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£räFrírrÝN)r-rÜrhr|r}rÖr]rrrzr>rrÞr\ÚmakeConnectionr¶r!rr—r˜©rCr™rfrïrerŒrDrDrEÚ!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£räFríNrvrrÝ)r-rÜrhr|r}rÖr]rrrzr>r?rÞr\rõr¡r—r˜rrárAr¶r!rrörDrDrEÚ$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£räFrírN)r-rÜrhr|r}rÖr]rrrzr>r¡r—r˜rráZ connectorsZstoppedConnectingrîrDrDrEÚ'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£räròFrÚrrÝN)r-rÜrhr|r}rÖr]rrrzr>rrfrÞZadvancer°Z passwordDelayÚflushr—r˜r+rrŸrDrDrEÚ"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“qSrD)r6rnró)Ú.0ÚkÚvrDrDrEÚ :sz6NewConnectionTests.setupKeyChecker..N)Úitemsr(r'r‚)rCrZusersÚmappingÚcheckerrDrDrEÚ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©ÚkeysrÖrÛrrÝN)r6rnr:rrr~r9r-rÜrhr|r}rÖr]rrrzr>rrfrÞr—r˜r+rárerâ) rCÚbadKeyr™rfršrurŒrsrœrDrDrEÚ#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)rrrÖrÛrQrrÝrr‘N)$r6rnr:rrr~r9r-rÜrhr|r}rrÖr]rrrzr>rfrgrrÞrsr’rr“r”rMr•r–r—r˜rárerâ) rCrr™rfršrurŒrsr›rœrDrDrEÚtest_authenticationFallbackcs: ÷  ÿ     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£FrrrÝN)r6rnr9rrr~rPr€rUr-rÜrhr|r}rÖr]rrrzr>rrfrÞr¨r©re) rCÚkeyr™rfršrurŒrsrzrDrDrEÚ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írrÝN)r-rÜrhr~r|r}rÖr]rrrzr>rrfrÞrsr—r˜r+rárerârŸrDrDrEÚ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. rXr£F)rÖrÛÚ agentEndpointržrrÝéN)$r6rnr:r2rrfZblobrrrr~rrr-rÜrhr|r}rÖr]rPr€rUrrzr>rrÞÚrangersr¨r©reràrárâZclientIO) rCr Z agentServerr r™rfršrurŒrsÚirzrDrDrEÚ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)rPr€rUrŠrrrzr>rŽr¨ràrárerârªrDrDrEÚtest_loseConnections   z&NewConnectionTests.test_loseConnectionN)rGrHrIrJr†rŠrŽràrrærérêrìrðrñrôr÷rørùrûrrrr r rrrDrDrDrErÓ½s0 #    ,"(%0!3rÓc@s0eZdZdZdd„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Ôrmr£FrÚN)r{r†r*r"rÕr×r|rfror r…rØr-rÜrhr~r}rr]r™)rCrÖrDrDrEr†#s"  ÿøzExistingConnectionTests.setUpc Cs¢tƒ}t|_|j |¡}|jj ¡}z0t |jjd<|  |j |j jdd¡\}}}W5|jj ¡|jj  |¡X||_||_||_| |¡}|jj}t |d¡S)zz Create and return a new L{SSHCommandClientEndpoint} using the C{existingConnection} constructor. ržrrÝr£)rrrzr™r>r€rUÚcopyÚclearÚupdaterPrrfrhrÞrtÚ_clientÚ_pumpr¨reÚconnr-ZexistingConnection) rCrfršrUrurŒrsrzÚ connectionrDrDrErŠ;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. )rrsrtrrBrDrDrErŽ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)Ú assertFalsererârAr‹rDrDrErgsz2ExistingConnectionTests.assertClientTransportStateN)rGrHrIrJr†rŠrŽrrDrDrDrErs rc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S) ÚExistingConnectionHelperTestsz1 Tests for L{_ExistingConnectionHelper}. cCs| tttƒ¡dS)zT L{_ExistingConnectionHelper} implements L{_ISSHConnectionCreator}. N)rárr/r.rBrDrDrEræwsz,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¨ZsecureConnection)rCr_ÚhelperrDrDrEÚtest_secureConnection}sz3ExistingConnectionHelperTests.test_secureConnectioncCsttƒƒ}| 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©rCrrDrDrEÚ$test_cleanupConnectionNotImmediately‡s zBExistingConnectionHelperTests.test_cleanupConnectionNotImmediatelycCsttƒƒ}| tƒd¡dS)zœ L{_ExistingConnectionHelper.cleanupConnection} does nothing to the existing connection if called with C{immediate} set to C{True}. TNr r"rDrDrEÚ!test_cleanupConnectionImmediately’s z?ExistingConnectionHelperTests.test_cleanupConnectionImmediatelyN)rGrHrIrJrærr#r$rDrDrDrErrs   rc@seZdZeedœdd„ZdS)Ú_WriteDiscarder)rMÚreturncCsdS)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. rrDrLrDrDrEr²Ÿsz_WriteDiscarder.writeN)rGrHrIrÚintr²rDrDrDrEr%žsr%c@s4eZdZdZeddœdd„Zeeedœdd„ZdS) Ú_PTYPathzk A L{FilePath}-like object which can be opened to create a L{_ReadFile} with certain contents. N)Úcontentsr&cCs ||_dS)zz @param contents: L{bytes} which will be the contents of the L{_ReadFile} this path can open. N)r))rCr)rDrDrErV­sz_PTYPath.__init__)Úmoder&cCs|dks t‚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+)ÚAssertionErrorr%r))rCr*rDrDrEÚopen´s z _PTYPath.open) rGrHrIrJÚbytesrVÚstrrr,rDrDrDrEr(§sr(c@s`eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dS)ÚNewConnectionHelperTestsz, Tests for L{_NewConnectionHelper}. cCs| tttƒ¡dS)zO L{_NewConnectionHelper} implements L{_ISSHConnectionCreator}. N)rárr/r0rBrDrDrEræÄsz'NewConnectionHelperTests.test_interfacecCs| dtj¡dS)zK The default I{known_hosts} path is I{~/.ssh/known_hosts}. z~/.ssh/known_hostsN)r•r0Ú _KNOWN_HOSTSrBrDrDrEÚ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ˆSrTrD)Úclsr^rDrErWÖrXzANewConnectionHelperTests.test_defaultKnownHosts..N)rÚpatchr0rrÖr"rDr^rEÚ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. rms 127.0.0.1zCreated known_hosts file at z~/r0zPatched _KNOWN_HOSTS with N)rkror"rÕr*r×rÙr#ÚpathÚosÚ expanduserÚreplacer4r0r2ráZ hasHostKey)rCr r6rÖÚhomeÚdefaultZloadedrDrDrEÚ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)r0r¤rÛr)r"rDrDrEÚ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?)r(r0r¨rÛrbrá©rCÚttyrr_rDrDrEÚ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Õr0r¨rÛrbrr>rDrDrEÚ 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)r0r•r"r?r"rDrDrEÚ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)r0r4rrer!rárâ)rCrrrDrDrEr##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@seZdZdZdd„ZdS)zMNewConnectionHelperTests.test_cleanupConnectionImmediately..AbortableFcSs d|_dS)z7 Abort the connection. TNr@rBrDrDrErF9sz]NewConnectionHelperTests.test_cleanupConnectionImmediately..Abortable.abortConnectionN)rGrHrIrArFrDrDrDrEÚ Abortable6srCNT)r0r4r7rer!rárA)rCrCrrrDrDrEr$0s$ ÿ  z:NewConnectionHelperTests.test_cleanupConnectionImmediatelyN)rGrHrIrJrær1r5r<r=r@rArBr#r$rDrDrDrEr/¿s     r/)yrJÚos.pathr7ÚiorÚstructrÚtypingrZzope.interfacerZzope.interface.verifyrrrÇZtwisted.conch.errorrr r Ztwisted.conch.interfacesr Ztwisted.cred.checkersr Ztwisted.cred.portalr Ztwisted.internet.addressrZtwisted.internet.deferrrrrZtwisted.internet.errorrrrrZtwisted.internet.interfacesrrZtwisted.internet.protocolrrZtwisted.internet.testingrrrZtwisted.loggerrrZtwisted.python.compatr Ztwisted.python.failurer!Ztwisted.python.filepathr"Ztwisted.python.logr#Ztwisted.python.reflectr$Ztwisted.trial.unittestr%Ztwisted.conch.avatarr&Ztwisted.conch.checkersr'r(Ztwisted.conch.client.knownhostsr)r*Ztwisted.conch.endpointsr+r,r-r.r/r0Ztwisted.conch.sshr1Ztwisted.conch.ssh.agentr2Ztwisted.conch.ssh.channelr3Ztwisted.conch.ssh.connectionr4Ztwisted.conch.ssh.factoryr5Ztwisted.conch.ssh.keysr6Ztwisted.conch.ssh.transportr7Ztwisted.conch.ssh.userauthr8Ztwisted.conch.test.keydatar9r:r;r<ÚskiprZtwisted.test.iosimr=r>r?rKrPrRrSrZr]rdrkrqrrr{rÓrrr%r(r/rDrDrDrEÚs˜                           &1dU,