o Òó·iÀÛã@sˆdZddlZddlmZddlmZddlmZddl m Z ddl m Z m Z ddlZddlmZmZmZdd lmZdd lmZdd lmZdd lmZdd lmZmZmZmZddl m!Z!m"Z"m#Z#m$Z$ddl%m&Z&m'Z'ddl(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.ddl/m0Z0m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAmBZBddlCmDZDmEZEddlFmGZGmHZHmIZImJZJmKZKmLZLddlMmNZNddlOmPZPdd lQmRZRdd!lSmTZTdd"lUmVZVdd#lWmXZXdd$lYmZZZdd%l[m\Z\dd&l]m^Z^m_Z_m`Z`maZand'ZbecZVecZ\ecZTecZXecZRecZPecZEecZBecZ?dd(ldmeZemfZfGd)d*„d*eeƒZgGd+d,„d,eRƒZhGd-d.„d.eRƒZiGd/d0„d0eRƒZjGd1d2„d2ƒZkGd3d4„d4e)ƒZlGd5d6„d6ƒZmGd7d8„d8e\ƒZnGd9d:„d:eVƒZoe e&ƒGd;d<„d<ƒƒZpe e'ƒGd=d>„d>ƒƒZqGd?d@„d@ƒZrGdAdB„dBe=erƒZsGdCdD„dDe=erƒZtGdEdF„dFe=ƒZuGdGdH„dHeƒZvGdIdJ„dJƒZwGdKdL„dLe=ƒZxdS)Mz' Tests for L{twisted.conch.endpoints}. éN)ÚBytesIO)Úpack)ÚIO)Ú implementer)Ú verifyClassÚ verifyObject)Ú ConchErrorÚHostKeyChangedÚUserRejectedKey)Ú IConchUser)Ú'InMemoryUsernamePasswordDatabaseDontUse)ÚPortal)Ú IPv4Address)ÚCancelledErrorÚDeferredÚfailÚsucceed)ÚConnectingCancelledErrorÚConnectionDoneÚConnectionRefusedErrorÚProcessTerminated)ÚIAddressÚIStreamClientEndpoint)ÚFactoryÚProtocol)ÚEventLoggingObserverÚMemoryReactorClockÚStringTransport)ÚLogLevelÚglobalLogPublisher)Ú networkString)ÚFailure)ÚFilePath)Úmsg)Ú requireModule)Ú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. FcCó d|_dS)z} Abort the connection in a fake manner. This should really be implemented in the underlying module. TN©Úaborted©Úself©rEúgC:\Users\psant\Downloads\PAF backend\school\venv\Lib\site-packages\twisted/conch/test/test_endpoints.pyÚabortConnection]ó z&AbortableFakeTransport.abortConnectionN)Ú__name__Ú __module__Ú __qualname__Ú__doc__rBrGrErErErFr?Vs r?c@óeZdZdZdd„ZdS)ÚBrokenExecSessionzO L{BrokenExecSession} is a session on which exec requests always fail. cCódS)zÈ Fail all exec requests. @param data: Information about what is being executed. @type data: L{bytes} @return: C{0} to indicate failure @rtype: L{int} rNrE©rDÚdatarErErFÚ request_execkó zBrokenExecSession.request_execN©rIrJrKrLrRrErErErFrNfó rNc@rM)ÚWorkingExecSessionzS L{WorkingExecSession} is a session on which exec requests always succeed. cCrO)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} éNrErPrErErFrR}rSzWorkingExecSession.request_execNrTrErErErFrVxrUrVc@rM)Ú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} N)rrPrErErFrRs z#UnsatisfiedExecSession.request_execNrTrErErErFrXŠs rXc@seZdZdd„Zdd„ZdS)Ú TrivialRealmcCs i|_dS©N)Ú channelLookuprCrErErFÚ__init__žó zTrivialRealm.__init__cGstƒ}|j|_t|dd„fS)NcSódSrZrErErErErFÚ¤óz,TrivialRealm.requestAvatar..)r&r[r )rDZavatarIdZmindZ interfacesZavatarrErErFÚ requestAvatar¡szTrivialRealm.requestAvatarN)rIrJrKr\rarErErErFrYs rYc@seZdZdZdd„ZdS)ÚAddressSpyFactoryNcCs||_t ||¡SrZ)ÚaddressrÚ buildProtocol)rDrcrErErFrdªs zAddressSpyFactory.buildProtocol)rIrJrKrcrdrErErErFrb§ó rbc@s$eZdZdd„Zdd„Zdd„ZdS)ÚFixedResponseUIcCs ||_dSrZ©Úresult)rDrhrErErFr\°r]zFixedResponseUI.__init__cCs t|jƒSrZ)rrh©rDÚtextrErErFÚprompt³r]zFixedResponseUI.promptcCr^rZrErirErErFÚwarn¶szFixedResponseUI.warnN)rIrJrKr\rkrlrErErErFrf¯s rfc@s$eZdZedd„ƒZedd„ƒZdS)ÚFakeClockSSHUserAuthServercCó |jjjS)zy Use the C{attemptsBeforeDisconnect} value defined by the factory to make it easier to override. N)Ú transportÚfactoryÚattemptsBeforeDisconnectrCrErErFrq¼rHz3FakeClockSSHUserAuthServer.attemptsBeforeDisconnectcCrn)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). N)rorpÚreactorrCrErErFÚclockÄs z FakeClockSSHUserAuthServer.clockN)rIrJrKÚpropertyrqrsrErErErFrmºs  rmc@s2eZdZedd„ƒZedd„ƒZeedœZdZ dS)ÚCommandFactorycCódtjtdiS©Nóssh-rsa)rQ)r6Ú fromStringr<rCrErErFÚ publicKeysÏózCommandFactory.publicKeyscCrvrw)r6ryr:rCrErErFÚ privateKeysÓr{zCommandFactory.privateKeys)s ssh-userauthsssh-connectionrN) rIrJrKrtrzr|rmr4ZservicesrqrErErErFruÎs  þ ruc@s eZdZdS)Ú MemoryAddressN)rIrJrKrErErErFr}ãsr}c@s eZdZdZdd„Zdd„ZdS)ÚSingleUseMemoryEndpointa] L{SingleUseMemoryEndpoint} is a client endpoint which allows one connection to be set up and then exposes an API for moving around bytes related to that connection. @ivar pump: L{None} until a connection is attempted, then a L{IOPump} instance associated with the protocol which is connected. @type pump: L{IOPump} cCsd|_||_dS)z˜ @param server: An L{IProtocol} provider to which the client will be connected. @type server: L{IProtocol} provider N)ÚpumpÚ_server)rDÚserverrErErFr\ô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Ú Exceptionrdr}Ú BaseExceptionrr>r€r?r)rDrpÚprotocolrErErFr>ýs   ÿ  üzSingleUseMemoryEndpoint.connectN)rIrJrKrLr\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#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ÚpasswordrrrrYÚrealmr Úportalr ZpasswdDBZaddUserÚregisterCheckerrurpZdoStartÚ addCleanupZdoStoprÚ clientAddressÚ serverAddressrCrErErFÚ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 createN©ÚNotImplementedErrorÚ __class__rIrCrErErFÚcreate1ó ÿz)SSHCommandClientEndpointTestsMixin.createcCstd|jjfƒ‚)a™ Make an assertion about the connectedness of the given protocol's transport. Override this to implement either a check for the connection still being open or having been closed as appropriate. @param client: The client whose state is being checked. @param immediateClose: Boolean indicating whether the connection was closed immediately or not. z/%r did not implement assertClientTransportStateNr”©rDÚclientZimmediateCloserErErFÚassertClientTransportState:s  ÿÿz=SSHCommandClientEndpointTestsMixin.assertClientTransportStatecCr“)zˆ Do any remaining work necessary to complete an in-memory connection attempted initiated using C{self.reactor}. z# did not implement finishConnectionNr”rCrErErFÚfinishConnectionJr˜z3SSHCommandClientEndpointTestsMixin.finishConnectioncCsT| d¡}| d¡}t|d|j|jd}t|d|j|jd}t||||ƒ}|||fS)aw Set up an in-memory connection between protocols created by C{serverFactory} and C{clientFactory}. @return: A three-tuple. The first element is the protocol created by C{serverFactory}. The second element is the protocol created by C{clientFactory}. The third element is the L{IOPump} connecting them. NF)rƒZ hostAddressZ peerAddressT)rdr?rr‘r>)rDZ serverFactoryZ clientFactoryZclientProtocolZserverProtocolZclientTransportZserverTransportrrErErFÚ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 channelrrWóunknown channelFN)r—rrr†r>rœÚflushLoggedErrorsrÚassertInÚvaluerQÚ assertEqualÚlenÚfailureResultOfÚtrapr›) rDÚendpointrpÚ connectedrršrÚerrorsÚfrErErFÚ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)rNrŒr[r—rrr†r>rœr¥r¦rr£r¢r›©rDr§rpr¨rršrrªrErErFÚ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)rXrŒr[r—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)rVrŒr[r—rbrr†r>rœÚassertIsInstancercr,r£roZgetHostrrŠÚusernameÚcommand)rDr§rprršrrErErFÚ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) rVrŒr[r—rrr†r>rœÚsuccessResultOfÚassertIsNotNonero©rDr§rpr¨rršrr†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, worldóN)rVrŒr[r—rrr†r>rœr¶ÚappendÚ dataReceivedroÚidÚserviceÚchannelsÚwriterr£Újoin) rDr§rpr¨rršrr†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)rVrŒr[r—rrr†r>rœr¶r¼ÚconnectionLostror¾r¿rÀÚloseConnectionrr¦rr›) rDr§rpr¨rršrr†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¬FrN)rVrŒr[r—rrr†r>rœr¶r¼rÅror¾r¿rÀZ sendRequestrÆrr›) rDÚrequestZ requestArgr§rpr¨rršrr†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_zeroExitCode2sz4SSHCommandClientEndpointTestsMixin.test_zeroExitCodecCsHd}d}| dtd|ƒ¡}| t¡| ||jj¡| ||jj¡dS)rÊé{NrËrÌ)rÉrr¦rr£r¢rÍÚsignal)rDrÍrÑrÎrErErFÚ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_levelZ log_namespaceZshortSignalNameZ coreDumpedZ errorMessageZ languageTag)rrZ addObserverrZremoveObserverrÂr1ZNSrÉr¦rr£r¢rÍrÑÚhamcrestZ assert_thatZhas_itemZ has_entriesZequal_torÚinfo)rDZ logObserverrÍrÑÚpacketrÎZ logNamespacerErErFÚ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¡SrZ)r¼rE©ZrecorderrErFr_‹s z;SSHCommandClientEndpointTestsMixin.record..N)ror¾r¼Úsetattrr¿rÀ)rDrr†ÚeventÚnoArgsrÃrªrErÛrFÚrecordwsz)SSHCommandClientEndpointTestsMixin.recordc Cszt|jjd<| ¡}tƒ}t|_| |¡}| ¡\}}}|  |¡}|  ||d¡}|j   d¡|  ¡| dd |¡¡dS)z¢ The transport connected to the protocol has a C{write} method which sends bytes to the input of the command executing on the SSH server. r¬r½rºr»N)rVrŒr[r—rrr†r>rœr¶rßrorÁrr£r© rDr§rpr¨rršrr†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ºr»N)rVrŒr[r—rrr†r>rœr¶rßroZ writeSequencerr£rÂràrErErFÚtest_writeSequence§s   z5SSHCommandClientEndpointTestsMixin.test_writeSequenceN)F)rIrJrKrLr’r—r›rœrr«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. rxN)r‡r’r"ÚmktempZ hostKeyPathr*Ú knownHostsÚ addHostKeyrˆrprzr 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æÚuiN) r-Ú newConnectionrrrŠrˆr‰r‹rærfrCrErErFr—ÒsøzNewConnectionTests.createcCs| |j|jjdd¡S)z} Establish the first attempted TCP connection using the SSH server which C{self.factory} can create. réN)rrprrÚ 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ßrorÆrr£ZreportDisconnect)rDrršr†rrïrErErFÚ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)Ú assertTruerorBÚ disconnectingr™rErErFr›sz-NewConnectionTests.assertClientTransportStatecCs,t |jdd|j|j¡}| tt|ƒ¡dS)zY L{SSHCommandClientEndpoint} instances provide L{IStreamClientEndpoint}. ó dummy commandó dummy userN)r-rìrrrˆr‰rñrr©rDr§rErErFÚ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ìrrrˆ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_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êrrWN)r-rìrrrŠrˆr‰r‹rærfrrr†r>rîr£r r¤)rDr§rprèr‰ÚtimeoutZ bindAddressrErErFÚ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ìrrrˆr‰rærfrrr†r>rîZclientConnectionFailedr!rr¥r¦©rDr§rpÚdrErErFÚ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ìrrrˆr‰r*rårfrrr†r>rrprî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)r6ryr:Úpublicr*r"rårçr r‘rèr;rˆrfr-rìrrr‰rrr†r>rrprîr¥r¦r ) rDZfirstKeyræZ differentKeyrër§rpr¨rršrrªrErErFÚ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ìrrrˆr‰rærfrrr†r>rrîrdÚmakeConnectionrÅr!rr¥r¦©rDr§rprÿroršrErErFÚ!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ýNr‚rrí)r-rìrrrˆr‰rærfrrr†r>r?rîrdrr¯r¥r¦rrñrBrÅr!rrrErErFÚ$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ìrrrˆr‰rærfrrr†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ôrFrêrríN)r-rìrrrˆr‰rærfrrr†r>rrprîZadvancer¿Z passwordDelayÚflushr¥r¦r+r›r­rErErFÚ"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“qSrE)r6ryr)Ú.0ÚkÚvrErErFÚ :s"z6NewConnectionTests.setupKeyChecker..N)Úitemsr(r'rŽ)rDrZusersÚmappingÚcheckerrErErFÚ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)r6ryr:rrrŠr9r-rìrrrˆr‰rærfrrr†r>rrprîr¥r¦r+rñrorò) rDÚbadKeyr§rpr¨rršrrªrErErFÚ#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)rr‹rærërWrríržrŸN)$r6ryr:rrrŠr9r-rìrrrˆr‰r‹rærfrrr†r>rprqrrîrr rr¡r¢rQr£r¤r¥r¦rñrorò) rDrr§rpr¨rršrr©rªrErErFÚtest_authenticationFallbackcs8 ÷   ÿ    z.NewConnectionTests.test_authenticationFallbackc Cs¤t t¡}| |j|jti¡t|jjd<t j |j d|j|j |j |g|jtdƒd}tƒ}t|_| |¡}| |j|j jdd¡\}}}| |¡}| |j¡dS)z› If L{SSHCommandClientEndpoint} is initialized with any private keys, it will try to use them to authenticate with the SSH server. r¬r±FrrríN)r6ryr9rrrŠrVrŒr[r-rìrrrˆr‰rærfrrr†r>rrprîr¶r·ro) rDÚkeyr§rpr¨rršrr†rErErFÚ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ìrrrŠrˆr‰rærfrrr†r>rrprîrr¥r¦r+rñrorò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. r»r±F)rærëÚ agentEndpointr¬rríéN)$r6ryr:r2rrpZblobrrrrŠr~r-rìrrrˆr‰rærfrVrŒr[rr†r>rrîÚrangerr¶r·rorðrñròZclientIO) rDrZ agentServerrr§rpr¨rršrÚ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)rVrŒr[r—rrr†r>rœr¶rðrñroròr¸rErErFÚtest_loseConnections   z&NewConnectionTests.test_loseConnectionN)rIrJrKrLr’r—rœrðr›rörùrúrürrrrrr r rrrrrr r!rErErErFrã½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ärxr±FrêN)r‡r’r*r"rårçrˆrprzr r‘rèr-rìrrrŠr‰r‹rfr§)rDrærErErFr’#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¬rrír±N)rrr†r§r>rŒr[ÚcopyrVrrprrrîÚclearÚupdater€Ú_clientÚ_pumpr¶roÚconnr-ZexistingConnection) rDrpr¨r[rršrr†Ú 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. N)r(rr€r'rCrErErFrœ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)Ú assertFalseroròrBr™rErErFr›gsz2ExistingConnectionTests.assertClientTransportStateN)rIrJrKrLr’r—rœr›rErErErFr#s  r#c@r") ÚExistingConnectionHelperTestsz1 Tests for L{_ExistingConnectionHelper}. cCó| tttƒ¡dS)zT L{_ExistingConnectionHelper} implements L{_ISSHConnectionCreator}. N)rñrr/r.rCrErErFröwóz,ExistingConnectionHelperTests.test_interfacecCs(tƒ}t|ƒ}| || | ¡¡¡dS)z¸ L{_ExistingConnectionHelper.secureConnection} returns a L{Deferred} which fires with whatever object was fed to L{_ExistingConnectionHelper.__init__}. N)Úobjectr.ÚassertIsr¶ZsecureConnection)rDrhÚhelperrErErFÚ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.r/ÚcleanupConnection©rDr1rErErFÚ$test_cleanupConnectionNotImmediately‡ó zBExistingConnectionHelperTests.test_cleanupConnectionNotImmediatelycCr3)zœ L{_ExistingConnectionHelper.cleanupConnection} does nothing to the existing connection if called with C{immediate} set to C{True}. TNr4r6rErErFÚ!test_cleanupConnectionImmediately’r8z?ExistingConnectionHelperTests.test_cleanupConnectionImmediatelyN)rIrJrKrLrör2r7r9rErErErFr,rs  r,c@seZdZdedefdd„ZdS)Ú_WriteDiscarderrQÚreturncCrO)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. rNrErPrErErFrÁŸsz_WriteDiscarder.writeN)rIrJrKr/ÚintrÁrErErErFr:žsr:c@s8eZdZdZdeddfdd„Zdedeefdd „ZdS) Ú_PTYPathzk A L{FilePath}-like object which can be opened to create a L{_ReadFile} with certain contents. Úcontentsr;NcCs ||_dS)zz @param contents: L{bytes} which will be the contents of the L{_ReadFile} this path can open. N)r>)rDr>rErErFr\­s z_PTYPath.__init__ÚmodecCs|dksJ‚t|jƒS)z¾ If the mode is r+, return a file with the given contents as a line. @return: a buffer of the given contents, which will discard any writes given to it. zr+N)r:r>)rDr?rErErFÚopen´s  z _PTYPath.open) rIrJrKrLÚbytesr\Ústrrr@rErErErFr=§sr=c@sbeZdZdZdd„Zdd„Zddd „Zd d „Zd d „Zdd„Z dd„Z dd„Z dd„Z dd„Z dS)ÚNewConnectionHelperTestsz, Tests for L{_NewConnectionHelper}. cCr-)zO L{_NewConnectionHelper} implements L{_ISSHConnectionCreator}. N)rñrr/r0rCrErErFröÄr.z'NewConnectionHelperTests.test_interfacecCs| dtj¡dS)zK The default I{known_hosts} path is I{~/.ssh/known_hosts}. z~/.ssh/known_hostsN)r£r0Ú _KNOWN_HOSTSrCrErErFÚtest_defaultPathÊsz)NewConnectionHelperTests.test_defaultPathr;Nc 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ˆSrZrE)ÚclsZignoredrgrErFr_Ör`zANewConnectionHelperTests.test_defaultKnownHosts..N)r/Úpatchr0r0rær6rErgrFÚ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. rxs 127.0.0.1zCreated known_hosts file at z~/rDzPatched _KNOWN_HOSTS with N)rurzr"rår*rçrér#ÚpathÚosÚ expanduserÚreplacerHr0rFrñZ hasHostKey)rDrrJræÚ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)r0r²rër)r6rErErFÚ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ërkrñ©rDÚttyr1rhrErErFÚtest_ttyConsoleUIs ÿ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ërkr+rRrErErFÚ 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)r0r£r"rSr6rErErFÚ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)r0r4rror5rñrò)rDr1r*rErErFr7,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@rM)zMNewConnectionHelperTests.test_cleanupConnectionImmediately..AbortableFcSr@)z7 Abort the connection. TNrArCrErErFrGBs z]NewConnectionHelperTests.test_cleanupConnectionImmediately..Abortable.abortConnectionN)rIrJrKrBrGrErErErFÚ Abortable?rerWNT)r0r4r7ror5rñrB)rDrWr1r*rErErFr99s ÿ  z:NewConnectionHelperTests.test_cleanupConnectionImmediately)r;N)rIrJrKrLrörErIrPrQrTrUrVr7r9rErErErFrC¿s     rC)yrLÚos.pathrKÚ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<Úskipr/Ztwisted.test.iosimr=r>r?rNrVrXrYrbrfrmrur}r~r‡rãr#r,r:r=rCrErErErFÚsš                           &1dU,