o ¯bPÚã@s‚dZddlZddlmZddlmZddlmZddl m Z m Z ddl Z ddl mZmZmZddlmZdd lmZdd lmZdd lmZdd lmZmZmZmZdd lmZm Z m!Z!m"Z"ddl#m$Z$m%Z%ddl&m'Z'm(Z(ddl)m*Z*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7m8Z8ddl9m:Z:e5dƒre5dƒrddl;mZ>m?Z?ddl@mAZAmBZBddlCmDZDmEZEmFZFmGZGmHZHmIZImJZJddlKmLZLddlMmNZNdd lOmPZPdd!lQmRZRdd"lSmTZTdd#lUmVZVdd$lWmXZXdd%lYmZZZdd&l[m\Z\m]Z]m^Z^m_Z_nd'Z`eaZTeaZZeaZReaZVeaZPeaZNeaZBeaZ?eaZd?„d?ƒƒZpGd@dA„dAƒZqGdBdC„dCe:eqƒZrGdDdE„dEe:eqƒZsGdFdG„dGe:ƒZtGdHdI„dIƒZuGdJdK„dKe:ƒZvdS)Lz' Tests for L{twisted.conch.endpoints}. éN)ÚENOSYS)Úpack)Ú implementer)Ú verifyClassÚ verifyObject)Ú ConchErrorÚHostKeyChangedÚUserRejectedKey)Ú IConchUser)Ú'InMemoryUsernamePasswordDatabaseDontUse)ÚPortal)Ú IPv4Address)ÚCancelledErrorÚDeferredÚfailÚsucceed)ÚConnectingCancelledErrorÚConnectionDoneÚConnectionRefusedErrorÚProcessTerminated)ÚIAddressÚIStreamClientEndpoint)ÚFactoryÚProtocol)ÚLogLevelÚglobalLogPublisher)Ú networkString)ÚFailure)ÚFilePath)Úmsg)Ú requireModule)ÚEventLoggingObserverÚMemoryReactorClock)ÚTestCaseÚ cryptographyz pyasn1.type)Ú ConchUser)ÚInMemorySSHKeyDBÚSSHPublicKeyChecker)Ú ConsoleUIÚKnownHostsFile)ÚAuthenticationFailedÚSSHCommandAddressÚSSHCommandClientEndpointÚ_ExistingConnectionHelperÚ_ISSHConnectionCreatorÚ_NewConnectionHelperÚ _ReadFile)Úcommon)ÚSSHAgentServer)Ú SSHChannel)Ú SSHConnection)Ú SSHFactory)ÚKey)ÚSSHClientTransport)ÚSSHUserAuthServer)ÚprivateDSA_opensshÚprivateRSA_opensshÚ privateRSA_openssh_encrypted_aesÚpublicRSA_opensshz%can't run w/o cryptography and pyasn1)Ú FakeTransportÚconnect)ÚStringTransportc@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úC/usr/lib/python3/dist-packages/twisted/conch/test/test_endpoints.pyÚabortConnectionZó z&AbortableFakeTransport.abortConnectionN)Ú__name__Ú __module__Ú __qualname__Ú__doc__rCrHrFrFrFrGr@Ss 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_exechó zBrokenExecSession.request_execN©rJrKrLrMrSrFrFrFrGrOcó 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} érFrQrFrFrGrSzrTzWorkingExecSession.request_execNrUrFrFrFrGrWurVrWc@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]rfrFrFrFrGrZšs 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)r6Ú fromStringr<rDrFrFrGÚ publicKeysÍózCommandFactory.publicKeyscCr{r|)r6r~r:rDrFrFrGÚ privateKeysÑr€zCommandFactory.privateKeys)s ssh-userauthsssh-connectionrN) rJrKrLryrrrrr4ÚservicesrvrFrFrFrGrzÌs  þ rzc@s eZdZdS)Ú MemoryAddressN)rJrKrLrFrFrFrGrƒásrƒc@ó 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Úpasswordr"rwrZÚ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Úcreate/ó ÿ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ÚassertClientTransportState8s  ÿÿ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ÚfinishConnectionHr¤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œrr>)rEÚ serverFactoryÚ clientFactoryÚclientProtocolÚserverProtocolÚclientTransportÚserverTransportr†rFrFrGÚconnectedServerAndClientQs üü 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£rrrr>r©ÚflushLoggedErrorsrÚassertInÚvaluerRÚ assertEqualÚlenÚfailureResultOfÚtrapr¨) rEÚendpointruÚ connectedrˆr¦r†ÚerrorsÚfrFrFrGÚ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)rOr”r\r£rrrr>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£rrrr>r©Úcancelrºr»rr¨rÂrFrFrGÚtest_execCancelleds    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£rgrrr>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£rrrr>r©ÚsuccessResultOfÚassertIsNotNonert©rEr¼rur½rˆr¦r†rrFrFrGÚ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£rrrr>r©rÌÚappendÚ dataReceivedrtÚidÚserviceÚchannelsÚwriter†r¸Újoin) rEr¼rur½rˆr¦r†rrÓÚ 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£rrrr>r©rÌrÒÚconnectionLostrtrÔrÕrÖÚloseConnectionr†r»rr¨) rEr¼rur½rˆr¦r†rrÛ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£rrrr>r©rÌrÒrÛrtrÔrÕrÖÚ sendRequestrÜr†r¨) rEÚrequestÚ requestArgr¼rur½rˆr¦r†rrÛ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_zeroExitCode0sz4SSHCommandClientEndpointTestsMixin.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)r!rÚ addObserverršÚremoveObserverrØr1ÚNSrâr»rr¸r·rærêÚhamcrestÚ assert_thatÚhas_itemÚ has_entriesÚequal_torÚinfo)rEÚ logObserverrærêÚpacketrçÚ logNamespacerFrFrGÚtest_nonZeroExitSignalGs> ûÿ  úÿÿþ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Úrecordusz)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£rrrr>r©rÌrrtr×r†r¸rØ© rEr¼rur½rˆr¦r†rrÓrFrFrGÚ test_writes    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£rrrr>r©rÌrrtÚ writeSequencer†r¸rØrrFrFrGÚtest_writeSequence¥s   z5SSHCommandClientEndpointTestsMixin.test_writeSequenceN)F)rJrKrLrMržr£r¨r©r²rÀrÃrÅrËrÏrÚrÝrârèrërrr 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#„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)rŽržrÚmktempÚ hostKeyPathr)Ú knownHostsÚ addHostKeyrrurrrÚ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’rr‘r“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¦rr†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,rrwrr‘rrr©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¸Ú_creatorr‘r rFrFrGÚtest_defaultPort"s ÿz#NewConnectionTests.test_defaultPortcCs,tj|jdd|jdd}| d|jj¡dS)zU L{SSHCommandClientEndpoint} uses the C{port} argument if specified. rri®)r‘Nr#r rFrFrGÚ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’rr‘r“rrkrrrr>rr¸rr¹)rEr¼rurr‘ÚtimeoutÚ bindAddressrFrFrGÚtest_destination5s"ø  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,rrwrr‘rrkrrrr>rÚclientConnectionFailedrrrºr»©rEr¼ruÚdrFrFrGÚtest_connectionFailedMsù  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,rrwrr‘r)rrkrrrr>r²rurrºr»r rÂrFrFrGÚtest_userRejectedHostKeyes" ù   ÿ 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)r6r~r:Úpublicr)rrrrrrr;rrkr,rrwr‘rrrr>r²rurrºr»r) rEÚfirstKeyrÚ differentKeyrr¼rur½rˆr¦r†r¿rFrFrGÚtest_mismatchedHostKeys8ÿþø   ÿ 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,rrwrr‘rrkrrrr>r?rriÚmakeConnectionrÛrrrº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,rrwrr‘rrkrrrr>r@rrir6rÄrºr»rrrCrÛrrr7rFrFrGÚ$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,rrwrr‘rrkrrrr>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Ærr1FrrrN)r,rrwrr‘rrkrrrr>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)r6r~r2)Ú.0ÚkÚvrFrFrGÚ 8s"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)r6r~r:rIr•r’r9r,rrwrr‘rrkrrrr>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)rKr“rrrXrrr³r´N)$r6r~r:rIr•r’r9r,rrwrr‘r“rrkrrrr>rurvr²rr†rµrr¶r·rRr¸r¹rºr»rrtr) rErLr¼rur½rˆr¦r†r¾r¿rFrFrGÚtest_authenticationFallbackas8 ÷   ÿ    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ÆFrJrrN)r6r~r9rIr•r’rWr”r\r,rrwrr‘rrkrrrr>r²rurrÌrÍrt) rEÚkeyr¼rur½rˆr¦r†rrFrFrGÚ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’rr‘rrkrrrr>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)$r6r~r:r2rruÚblobrKrIr•r’r…r,rrwrr‘rrkrWr”r\rrr>r²rÚranger†rÌrÍrtrrrÚclientIO) rErOÚ agentServerrRr¼rur½rˆr¦r†ÚirrFrFrGÚ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£rrrr>r©rÌrrrtrrÎrFrFrGÚtest_loseConnections   z&NewConnectionTests.test_loseConnectionN)rJrKrLrMržr£r©rr¨r!r%r&r)r.r/r5r8r9r<r@rIrMrNrPrQrYrZrFrFrFrGr »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)rŽržr)rrrrrurrrrr,rrwr’r‘r“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Æ)rrrr¼r>r”r\ÚcopyrWr²rurwrÚclearÚupdater‡Ú_clientÚ_pumprÌrtÚconnr,ÚexistingConnection) rErur½r\rˆr¦r†rÚ connectionrFrFrGr£9s&    ÿ  ÿ  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. )rar†r‡r`rDrFrFrGr©Ws    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¨esz2ExistingConnectionTests.assertClientTransportStateN)rJrKrLrMržr£r©r¨rFrFrFrGr\s  r\c@r[) ÚExistingConnectionHelperTestsz1 Tests for L{_ExistingConnectionHelper}. cCó| tttƒ¡dS)zT L{_ExistingConnectionHelper} implements L{_ISSHConnectionCreator}. N)rrr.r-rDrFrFrGr!uó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-riÚcleanupConnection©rErlrFrFrGÚ$test_cleanupConnectionNotImmediately…ó zBExistingConnectionHelperTests.test_cleanupConnectionNotImmediatelycCrn)zœ L{_ExistingConnectionHelper.cleanupConnection} does nothing to the existing connection if called with C{immediate} set to C{True}. TNrorqrFrFrGÚ!test_cleanupConnectionImmediatelyrsz?ExistingConnectionHelperTests.test_cleanupConnectionImmediatelyN)rJrKrLrMr!rmrrrtrFrFrFrGrfps  rfc@r„)Ú_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)rErvrFrFrGr]¢s z_PTYPath.__init__cCs|dkr t|jƒSttdƒ‚)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 implemented)r0rvÚOSErrorr)rEÚmoderFrFrGÚopen©s  z _PTYPath.openN)rJrKrLrMr]ryrFrFrFrGruœs ruc@s`eZdZdZdd„Zdd„Zdd„Zdd „Zd d „Zd d „Z dd„Z dd„Z dd„Z dd„Z dS)ÚNewConnectionHelperTestsz, Tests for L{_NewConnectionHelper}. cCrg)zO L{_NewConnectionHelper} implements L{_ISSHConnectionCreator}. N)rrr.r/rDrFrFrGr!¼rhz'NewConnectionHelperTests.test_interfacecCs| dtj¡dS)zK The default I{known_hosts} path is I{~/.ssh/known_hosts}. z~/.ssh/known_hostsN)r¸r/Ú _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)riÚpatchr/rjrrqrFrlrGÚ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)rzrrrr)rrrÚpathÚosÚ expanduserÚreplacerr/r}rÚ hasHostKey)rErOrrÚ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)r/rÇrr(rqrFrFrGÚ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?)rur/rÌrrpr©rEÚttyrlrmrFrFrGÚ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?)rrr/rÌrrprer‹rFrFrGÚ test_nottyUIs ÿ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¸rrŒrqrFrFrGÚ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)r/r4r?rtrprr)rErlrdrFrFrGrrsÿ 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. TNrBrDrFrFrGrH1s z]NewConnectionHelperTests.test_cleanupConnectionImmediately..Abortable.abortConnectionN)rJrKrLrCrHrFrFrFrGÚ Abortable.rjrNT)r/r4r7rtrprrC)rErrlrdrFrFrGrt(s ÿ  z:NewConnectionHelperTests.test_cleanupConnectionImmediatelyN)rJrKrLrMr!r|r€r‰rŠrrŽrrrrtrFrFrFrGrz·s    rz)wrMÚos.pathr‚ÚerrnorÚstructrÚzope.interfacerÚzope.interface.verifyrrrøÚtwisted.conch.errorrrr Ú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.loggerrrÚtwisted.python.compatrÚtwisted.python.failurerÚtwisted.python.filepathrÚtwisted.python.logrÚtwisted.python.reflectr Útwisted.test.proto_helpersr!r"Útwisted.trial.unittestr#Útwisted.conch.avatarr%Útwisted.conch.checkersr&r'Útwisted.conch.client.knownhostsr(r)Útwisted.conch.endpointsr*r+r,r-r.r/r0Útwisted.conch.sshr1Útwisted.conch.ssh.agentr2Útwisted.conch.ssh.channelr3Útwisted.conch.ssh.connectionr4Útwisted.conch.ssh.factoryr5Útwisted.conch.ssh.keysr6Útwisted.conch.ssh.transportr7Útwisted.conch.ssh.userauthr8Útwisted.conch.test.keydatar9r:r;r<ÚskipriÚtwisted.test.iosimr=r>r?r@rOrWrYrZrgrkrrrzrƒr…rŽr r\rfrurzrFrFrFrGÚs˜              $          &1dU,