U ¹êW[!Õã@sšdZddlZddlmZddlmZddlZddlm Z m Z ddl m Z ddl mZmZddlmZmZdd lmZdd lmZdd lmZdd lmZdd lmZmZddlmZm Z ddl!m"Z"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(ddl)m*Z*ddl+m,Z,ddl-m.Z.m/Z/ddl&m0Z0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9m:Z:m;Z;edƒr.edƒr.ddlm?Z?ddl@mAZAddlBmCZCddlDmEZEdd lFmGZGdd!lHmIZIdd"lJmKZKmLZLdd#lMmNZNmOZOdd$lPmQZQdd%lRmSZSmTZTmUZUmVZVdd&lWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^dd'l_m`Z`n(d(ZaebZ?ZAZCZEZGZIZKZNZQdd)l-mcZcdd*ldmeZemfZfGd+d,„d,eeƒZgGd-d.„d.eGƒZhGd/d0„d0eGƒZiGd1d2„d2eGƒZjGd3d4„d4ebƒZkGd5d6„d6eƒZlGd7d8„d8ebƒZmGd9d:„d:eAƒZnGd;d<„d„d>ebƒƒZpe eƒGd?d@„d@ebƒƒZqGdAdB„dBebƒZrGdCdD„dDe,erƒZsGdEdF„dFe,erƒZtGdGdH„dHe,ƒZuGdIdJ„dJebƒZvGdKdL„dLe,ƒZwdS)Mz' Tests for L{twisted.conch.endpoints}. éN)Úpack)ÚENOSYS)Ú verifyObjectÚ verifyClass)Ú implementer)ÚglobalLogPublisherÚLogLevel)Ú iteritemsÚ networkString)ÚFailure)ÚFilePath)Úmsg)Ú requireModule)ÚIAddressÚIStreamClientEndpoint)ÚFactoryÚProtocol)ÚCancelledErrorÚDeferredÚsucceedÚfail)ÚConnectionDoneÚConnectionRefusedError)Ú IPv4Address)ÚTestCase)ÚEventLoggingObserverÚMemoryReactorClock)ÚProcessTerminatedÚConnectingCancelledError)ÚPortal)Ú'InMemoryUsernamePasswordDatabaseDontUse)Ú IConchUser)Ú ConchErrorÚUserRejectedKeyÚHostKeyChangedZ cryptographyz pyasn1.type)Úcommon)Ú SSHFactory)ÚSSHUserAuthServer)Ú SSHConnection)ÚKey)Ú SSHChannel)ÚSSHAgentServer)ÚKnownHostsFileÚ ConsoleUI)ÚSSHPublicKeyCheckerÚInMemorySSHKeyDB)Ú ConchUser)ÚpublicRSA_opensshÚprivateRSA_opensshÚ privateRSA_openssh_encrypted_aesÚprivateDSA_openssh)Ú_ISSHConnectionCreatorÚAuthenticationFailedÚSSHCommandAddressÚSSHCommandClientEndpointÚ _ReadFileÚ_NewConnectionHelperÚ_ExistingConnectionHelper)ÚSSHClientTransportz%can't run w/o cryptography and pyasn1)ÚStringTransport)Ú FakeTransportÚconnectc@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©rEúC/usr/lib/python3/dist-packages/twisted/conch/test/test_endpoints.pyÚabortConnectionNsz&AbortableFakeTransport.abortConnectionN)Ú__name__Ú __module__Ú __qualname__Ú__doc__rBrGrErErErFr@Gsr@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} rrE©rDÚdatarErErFÚ request_exec\s zBrokenExecSession.request_execN©rHrIrJrKrOrErErErFrLXsrLc@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} érErMrErErFrOns zWorkingExecSession.request_execNrPrErErErFrQjsrQc@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} )rrMrErErFrOs z#UnsatisfiedExecSession.request_execNrPrErErErFrS|srSc@seZdZdd„Zdd„ZdS)Ú TrivialRealmcCs i|_dS©N)Ú channelLookuprCrErErFÚ__init__szTrivialRealm.__init__cGstƒ}|j|_t|dd„fS)NcSsdSrUrErErErErFÚ—óz,TrivialRealm.requestAvatar..)r0rVr!)rDZavatarIdZmindZ interfacesZavatarrErErFÚ requestAvatar”szTrivialRealm.requestAvatarN)rHrIrJrWrZrErErErFrTsrTc@seZdZdZdd„ZdS)ÚAddressSpyFactoryNcCs||_t ||¡SrU)ÚaddressrÚ buildProtocol)rDr\rErErFr]žszAddressSpyFactory.buildProtocol)rHrIrJr\r]rErErErFr[›sr[c@s$eZdZdd„Zdd„Zdd„ZdS)ÚFixedResponseUIcCs ||_dSrU©Úresult)rDr`rErErFrW¥szFixedResponseUI.__init__cCs t|jƒSrU)rr`©rDÚtextrErErFÚprompt©szFixedResponseUI.promptcCsdSrUrErarErErFÚwarn­szFixedResponseUI.warnN)rHrIrJrWrcrdrErErErFr^¤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ÚattemptsBeforeDisconnectrCrErErFrhµ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). )rfrgÚreactorrCrErErFÚclock¾sz FakeClockSSHUserAuthServer.clockN)rHrIrJÚpropertyrhrjrErErErFre²s rec@s2eZdZedd„ƒZedd„ƒZeedœZdZ dS)ÚCommandFactorycCsdtjtdiS©Nóssh-rsa)rN)r)Ú fromStringr1rCrErErFÚ publicKeysÊs ÿzCommandFactory.publicKeyscCsdtjtdiSrm)r)ror2rCrErErFÚ privateKeysÑs ÿzCommandFactory.privateKeys)s ssh-userauthsssh-connectionrN) rHrIrJrkrprqrer(ÚservicesrhrErErErFrlÉs  þ rlc@s eZdZdS)Ú MemoryAddressN)rHrIrJrErErErFrsäsrsc@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)rDÚserverrErErFrWõsz SingleUseMemoryEndpoint.__init__cCsf|jdk rtdƒ‚z| tƒ¡}WntƒYSXt|jt|jdd|t|ddƒ|_t|ƒSdS)Nz(SingleUseMemoryEndpoint was already usedT©ÚisServerF) ruÚ Exceptionr]rsrr?rvr@r)rDrgÚprotocolrErErFr?ÿs   ÿ ýzSingleUseMemoryEndpoint.connectN)rHrIrJrKrWr?rErErErFrtês  rtc@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ÚpasswordrrirTÚrealmrÚportalr ZpasswdDBZaddUserÚregisterCheckerrlrgZdoStartÚ addCleanupZdoStoprÚ clientAddressÚ serverAddressrCrErErFÚsetUps"    z(SSHCommandClientEndpointTestsMixin.setUpcCstd|jjfƒ‚dS)z£ Create and return a new L{SSHCommandClientEndpoint} to be tested. Override this to implement creation in an interesting way the endpoint. z%r did not implement createN©ÚNotImplementedErrorÚ __class__rHrCrErErFÚcreate2s ÿ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ˆ©rDÚclientZimmediateCloserErErFÚassertClientTransportState;s ÿÿz=SSHCommandClientEndpointTestsMixin.assertClientTransportStatecCstd|jjfƒ‚dS)zˆ Do any remaining work necessary to complete an in-memory connection attempted initiated using C{self.reactor}. z%%r did not implement finishConnectionNrˆrCrErErFÚfinishConnectionKs ÿÿ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)ryZ hostAddressZ peerAddressT)r]r@r…r†r?)rDZ serverFactoryZ clientFactoryZclientProtocolZserverProtocolZclientTransportZserverTransportrurErErFÚconnectedServerAndClientUs*  þþÿ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 channelrrRóunknown channelFN)r‹rrr{r?rÚflushLoggedErrorsr"ÚassertInÚvaluerNÚ assertEqualÚlenÚfailureResultOfÚtraprŽ) rDÚendpointrgÚ connectedrwrruÚerrorsÚfrErErFÚtest_channelOpenFailurens  ÿ  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)rLrrVr‹rrr{r?rr˜r™r"r–r•rŽ©rDršrgr›rwrrurrErErFÚ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)rSrrVr‹rrr{r?rÚcancelr˜r™rrŽr rErErFÚ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)rQrrVr‹r[rr{r?rÚassertIsInstancer\r7r–rfZgetHostrwrZusernameZcommand)rDršrgrwrrurErErFÚ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) rQrrVr‹rrr{r?rÚsuccessResultOfÚassertIsNotNonerf©rDršrgr›rwrrur{rErErFÚ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, worldrYN)rQrrVr‹rrr{r?rr§ÚappendÚ dataReceivedrfÚidÚserviceÚchannelsÚwriterur–Újoin) rDršrgr›rwrrur{r­Ú channelIdrErErFÚ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)rQrrVr‹rrr{r?rr§r¬ÚconnectionLostrfr®r¯r°ÚloseConnectionrur™rrŽ) rDršrgr›rwrrur{rµr³rErErFÚ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)rQrrVr‹rrr{r?rr§r¬rµrfr®r¯r°Z sendRequestr¶rurŽ) rDZrequestZ requestArgršrgr›rwrrur{rµr³ZchannelrErErFÚ_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)rDÚexitCodeÚexcrErErFÚtest_zeroExitCode9sz4SSHCommandClientEndpointTestsMixin.test_zeroExitCodecCsHd}d}| dtd|ƒ¡}| t¡| ||jj¡| ||jj¡dS)r¹é{Nrºr»)r¸rr™rr–r•r¼Úsignal)rDr¼rÀr½rErErFÚtest_nonZeroExitStatusDs  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érYsTERMósmessagesen-USs exit-signalz'twisted.conch.endpoints._CommandChannelTÚmessage)Z log_levelZ log_namespaceZshortSignalNameZ coreDumpedZ errorMessageZ languageTag)rrZ addObserverr„ZremoveObserverr²r%ZNSr¸r™rr–r•r¼rÀÚhamcrestZ assert_thatZhas_itemZ has_entriesZequal_torÚinfo)rDZ logObserverr¼rÀZpacketr½Z logNamespacerErErFÚtest_nonZeroExitSignalRs< û   úÿÿþ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¡SrU)r¬rE©ZrecorderrErFrX‘rYz;SSHCommandClientEndpointTestsMixin.record..)rfr®r¬Úsetattrr¯r°)rDrwr{ZeventÚnoArgsr³rrErÈrFÚrecord}sz)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«rYN)rQrrVr‹rrr{r?rr§rËrfr±rur–r²© rDršrgr›rwrrur{r­rErErFÚ 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«rYN)rQrrVr‹rrr{r?rr§rËrfZ writeSequencerur–r²rÌrErErFÚtest_writeSequence¯s   z5SSHCommandClientEndpointTestsMixin.test_writeSequenceN)F)rHrIrJrKr‡r‹rŽrrržr¡r£r¦rªr´r·r¸r¾rÁrÇrËrÍrÎrErErErFr|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. rnN)r|r‡r ÚmktempZ hostKeyPathr,Ú knownHostsÚ addHostKeyr}rgrpr r†ÚhostÚsaverCrErErFr‡Ë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) r8Ú newConnectionrirr}r~r€rÒr^rCrErErFr‹ÜsýzNewConnectionTests.createcCs| |j|jjdd¡S)z} Establish the first attempted TCP connection using the SSH server which C{self.factory} can create. ré)rrgriÚ tcpClientsrCrErErFrç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Ërfr¶rur–ZreportDisconnect)rDrwrr{rurÛrErErFÚ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)Ú assertTruerfrBÚ disconnectingrŒrErErFrŽsz-NewConnectionTests.assertClientTransportStatecCs,t |jdd|j|j¡}| tt|ƒ¡dS)zY L{SSHCommandClientEndpoint} instances provide L{IStreamClientEndpoint}. ó dummy commandó dummy userN)r8rØrir}r~rÝrr©rDršrErErFÚtest_interface"sþ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©r8rØrir}r–Z_creatorr~rárErErFÚ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árErErFÚtest_specifiedPort6sþ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ÖrrRN)r8rØrirr}r~r€rÒr^rrr{r?rÚr–r r—)rDršrgrÔr~ZtimeoutZ bindAddressrErErFÚtest_destination@s"ý 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)r8rØrir}r~rÒr^rrr{r?rÚZclientConnectionFailedr rr˜r™©rDršrgÚdrErErFÚtest_connectionFailedSsý 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)r8rØrir}r~r,rÑr^rrr{r?rrgrÚr˜r™r#r rErErFÚ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)r)ror2Úpublicr,r rÑrÓr r†rÔr3r}r^r8rØrir~rrr{r?rrgrÚr˜r™r$) rDZfirstKeyrÒZ differentKeyr×ršrgr›rwrrurrErErFÚtest_mismatchedHostKey~s< ÿÿ ý ÿ  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)r8rØrir}r~rÒr^rrr{r?r=rÚr]ÚmakeConnectionrµr rr˜r™©rDršrgrêrfrrErErFÚ!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èNrxrrÙ)r8rØrir}r~rÒr^rrr{r?r@rÚr]rðr¢r˜r™rrÝrBrµr rrñrErErFÚ$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)r8rØrir}r~rÒr^rrr{r?r¢r˜r™rrÝZ connectorsZstoppedConnectingrérErErFÚ'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)r8rØrir}r~rÒr^rrr{r?rrgrÚZadvancer¯Z passwordDelayÚflushr˜r™r6rŽr rErErFÚ"test_passwordAuthenticationFailureîs,ý ÿ   z5NewConnectionTests.test_passwordAuthenticationFailurecCs0tdd„t|ƒDƒƒ}tt|ƒƒ}| |¡dS)a¼ Create an L{ISSHPrivateKey} checker which recognizes C{users} and add it to C{portal}. @param portal: A L{Portal} to which to add the checker. @type portal: L{Portal} @param users: The users and their keys the checker will recognize. Keys are byte strings giving user names. Values are byte strings giving OpenSSH-formatted private keys. @type users: L{dict} cSs$g|]\}}|t |¡ ¡gf‘qSrE)r)rorî)Ú.0ÚkÚvrErErFÚ sÿz6NewConnectionTests.setupKeyChecker..N)Údictr r.r/rƒ)rDr‚ZusersÚmappingZcheckerrErErFÚsetupKeyCheckers ÿ 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)r)ror2rýr‚rr4r8rØrir}r~rÒr^rrr{r?rrgrÚr˜r™r6rÝrfrÞ) rDÚbadKeyršrgr›rwrrurrErErFÚ#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)rÿr€rÒr×rRrrÙr‘r’N)$r)ror2rýr‚rr4r8rØrir}r~r€rÒr^rrr{r?rgrhrrÚrur“r"r”r•rNr–r—r˜r™rÝrfrÞ) rDrršrgr›rwrrurœrrErErFÚtest_authenticationFallbackBs@ ý ÿ  ÿ  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¤FrþrrÙN)r)ror4rýr‚rrQrrVr8rØrir}r~rÒr^rrr{r?rrgrÚr§r¨rf) rDÚkeyršrgr›rwrrur{rErErFÚtest_publicKeyAuthenticationls,  þ ÿ  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)r8rØrirr}r~rÒr^rrr{r?rrgrÚrur˜r™r6rÝrfrÞr rErErFÚ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. rYr¤F)rÒr×Ú agentEndpointrŸrrÙéN)$r)ror2r+rrgZblobrÿrýr‚rrtr8rØrir}r~rÒr^rQrrVrr{r?rrÚÚrangerur§r¨rfrÜrÝrÞZclientIO) rDrZ agentServerrršrgr›rwrruÚir{rErErFÚ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)rQrrVr‹rrr{r?rr§rÜrÝrfrÞr©rErErFÚtest_loseConnectionÌs   z&NewConnectionTests.test_loseConnectionN)rHrIrJrKr‡r‹rrÜrŽrârårærçrërìrïròrórôrörýrrrrr r rErErErFrÏÆs0  $   &"*-rÏ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Ðrnr¤FrÖN)r|r‡r,r rÑrÓr}rgrpr r†rÔr8rØrirr~r€r^rš)rDrÒrErErFr‡é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¤)rrr{ršr?rrVÚcopyÚclearÚupdaterQrrgrirÚrvÚ_clientÚ_pumpr§rfZconnr8ZexistingConnection) rDrgr›rVrwrrur{Ú connectionrErErFr‹ý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. )rrurvrrCrErErFrs     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)Ú assertFalserfrÞrBrŒrErErFrŽ+sz2ExistingConnectionTests.assertClientTransportStateN)rHrIrJrKr‡r‹rrŽrErErErFr äs r c@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S) ÚExistingConnectionHelperTestsz1 Tests for L{_ExistingConnectionHelper}. cCs| tttƒ¡dS)zT L{_ExistingConnectionHelper} implements L{_ISSHConnectionCreator}. N)rÝrr5r;rCrErErFrâ;sÿ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§ZsecureConnection)rDr`ÚhelperrErErFÚtest_secureConnectionCs  ÿz3ExistingConnectionHelperTests.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©rDrrErErFÚ$test_cleanupConnectionNotImmediatelyOs 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}. TNrrrErErFÚ!test_cleanupConnectionImmediately[s z?ExistingConnectionHelperTests.test_cleanupConnectionImmediatelyN)rHrIrJrKrârrrrErErErFr7s   rc@s eZdZdZdd„Zdd„ZdS)Ú_PTYPathzk A L{FilePath}-like object which can be opened to create a L{_ReadFile} with certain contents. cCs ||_dS)zz @param contents: L{bytes} which will be the contents of the L{_ReadFile} this path can open. N)Úcontents)rDrrErErFrWmsz_PTYPath.__init__cCs |dkrt|jƒSttdƒ‚dS)zÕ If the mode is r+, return a L{_ReadFile} with the contents given to this path's initializer. @raise OSError: If the mode is unsupported. @return: A L{_ReadFile} instance zrb+zFunction not implementedN)r9rÚOSErrorr)rDÚmoderErErFÚopenus  z _PTYPath.openN)rHrIrJrKrWr"rErErErFrhsrc@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Ýrr5r:rCrErErFrâˆsÿz'NewConnectionHelperTests.test_interfacecCs| dtj¡dS)zK The default I{known_hosts} path is I{~/.ssh/known_hosts}. z~/.ssh/known_hostsN)r–r:Ú _KNOWN_HOSTSrCrErErFÚtest_defaultPathsÿz)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ˆSrUrE)Úclsr_rErFrXžrYzANewConnectionHelperTests.test_defaultKnownHosts..N)rÚpatchr:rrÒrrEr_rFÚtest_defaultKnownHosts˜sÿz/NewConnectionHelperTests.test_defaultKnownHostscCs˜tƒjd}t| ¡ƒ}t|ƒ}| d|¡| ¡td|jfƒt j  d¡}|j  |d¡}|  t d|¡td|fƒt  ¡}| | d|¡¡dS)z´ Existing entries in the I{known_hosts} file are reflected by the L{KnownHostsFile} created by L{_NewConnectionHelper} when none is supplied to it. rns 127.0.0.1zCreated known_hosts file at %rz~/r$zPatched _KNOWN_HOSTS with %rN)rlrpr rÑr,rÓrÕr ÚpathÚosÚ expanduserÚreplacer(r:r&rÝZ hasHostKey)rDrr*rÒÚhomeÚdefaultZloadedrErErFÚ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)r:r¥r×r-rrErErFÚ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?)rr:r§r×rcrÝ©rDÚttyrr`rErErFÚ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Ñr:r§r×rcrr2rErErFÚ 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)r:r–r r3rrErErFÚtest_defaultTTYFilenameâsÿ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)r:r(r=rfrrÝrÞ)rDrrrErErFrì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. TNrArCrErErFrGsz]NewConnectionHelperTests.test_cleanupConnectionImmediately..Abortable.abortConnectionN)rHrIrJrBrGrErErErFÚ Abortableþsr7NT)r:r(r<rfrrÝrB)rDr7rrrErErFrùs$ÿ  z:NewConnectionHelperTests.test_cleanupConnectionImmediatelyN)rHrIrJrKrâr%r)r0r1r4r5r6rrrErErErFr#„s     r#)xrKÚos.pathr+ZstructrÚerrnorrÅZzope.interface.verifyrrZzope.interfacerZtwisted.loggerrrZtwisted.python.compatr r Ztwisted.python.failurer Ztwisted.python.filepathr Ztwisted.python.logr Ztwisted.python.reflectrZtwisted.internet.interfacesrrZtwisted.internet.protocolrrZtwisted.internet.deferrrrrZtwisted.internet.errorrrZtwisted.internet.addressrZtwisted.trial.unittestrZtwisted.test.proto_helpersrrrrZtwisted.cred.portalrZtwisted.cred.checkersr Ztwisted.conch.interfacesr!Ztwisted.conch.errorr"r#r$Ztwisted.conch.sshr%Ztwisted.conch.ssh.factoryr&Ztwisted.conch.ssh.userauthr'Ztwisted.conch.ssh.connectionr(Ztwisted.conch.ssh.keysr)Ztwisted.conch.ssh.channelr*Ztwisted.conch.ssh.agentr+Ztwisted.conch.client.knownhostsr,r-Ztwisted.conch.checkersr.r/Ztwisted.conch.avatarr0Ztwisted.conch.test.keydatar1r2r3r4Ztwisted.conch.endpointsr5r6r7r8r9r:r;Ztwisted.conch.ssh.transportr<Úskiprr=Ztwisted.test.iosimr>r?r@rLrQrSrTr[r^rerlrsrtr|rÏr rrr#rErErErFÚs–                    $þÿÿ   %9"S1