IivSrSSKrSSKrSSKrSSKrSSKrSSKrSSKJrJ r J r J r SSK J r SSKJrJrJrJr SSKrSSKJr SSKJrJr SSKJr SS KJr SS KJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r;Jr>J?r?J@r@JArAJBrBJCrCJDrDJErEJFrFJGrGJHrHJIrIJJrJJKrKJLrLJMrMJNrN SS KOJPrPJQrQ SS KRJSrS SS KTJUrU SSKVJWrW SSKXJYrYJZrZ SSK[J\r\ SSK]J^r^J_r_ SSK`Jara SSKbJcrcJdrdJere SSKfJgrgJhrhJiri SSKjJkrk SSKlJmrmJnrn SSKoJprp SSKqJrrr SSKsJtrt SSKuJvrv SSKwJxrx SSKyJzrzJ{r{J|r|J}r}J~r~Jr SSKJrJrJr SSKJr /rSrSSKr\GR"\5 "S S!\GR\5r"S"S#5r"S$S%5r"S&S'\5rg!\a SSKJr Naf=f)(z Core protocol implementation N)md5sha1sha256sha512)default_backend) algorithmsCiphermodesaead)util) AuthHandlerAuthOnlyHandler)GSSAuth)Channel)2 xffffffffcMSG_CHANNEL_OPEN cMSG_IGNOREcMSG_GLOBAL_REQUESTDEBUG MSG_KEXINIT MSG_IGNOREMSG_DISCONNECT MSG_DEBUGERRORWARNINGcMSG_UNIMPLEMENTEDINFO cMSG_KEXINIT cMSG_NEWKEYS MSG_NEWKEYScMSG_REQUEST_SUCCESScMSG_REQUEST_FAILURECONNECTION_FAILED_CODE'OPEN_FAILED_ADMINISTRATIVELY_PROHIBITEDOPEN_SUCCEEDEDcMSG_CHANNEL_OPEN_FAILUREcMSG_CHANNEL_OPEN_SUCCESSMSG_GLOBAL_REQUESTMSG_REQUEST_SUCCESSMSG_REQUEST_FAILUREcMSG_SERVICE_REQUESTMSG_SERVICE_ACCEPTMSG_CHANNEL_OPEN_SUCCESSMSG_CHANNEL_OPEN_FAILUREMSG_CHANNEL_OPENMSG_CHANNEL_SUCCESSMSG_CHANNEL_FAILUREMSG_CHANNEL_DATAMSG_CHANNEL_EXTENDED_DATAMSG_CHANNEL_WINDOW_ADJUSTMSG_CHANNEL_REQUESTMSG_CHANNEL_EOFMSG_CHANNEL_CLOSEMIN_WINDOW_SIZEMIN_PACKET_SIZEMAX_WINDOW_SIZEDEFAULT_WINDOW_SIZEDEFAULT_MAX_PACKET_SIZEHIGHEST_USERAUTH_MESSAGE_IDMSG_UNIMPLEMENTED MSG_NAMES MSG_EXT_INFO cMSG_EXT_INFObyte_ord)ZlibCompressorZlibDecompressor)DSSKey) Ed25519Key) KexCurve25519)KexGex KexGexSHA256) KexGroup1) KexGroup14KexGroup14SHA256)KexGroup16SHA512) KexNistp256 KexNistp384 KexNistp521) KexGSSGex KexGSSGroup1 KexGSSGroup14)Message) PacketizerNeedRekeyException) ModulusPack)RSAKey)ECDSAKey)ServerInterface) SFTPClient)BadAuthenticationTypeChannelExceptionIncompatiblePeerMessageOrderErrorProxyCommandFailure SSHException)ClosingContextManager clamp_valueb) TripleDESc>[HnUR5 M gN)_active_threads stop_thread)thrs 8/venv/lib/python3.13/site-packages/paramiko/transport.py_join_lingering_threadsrls cB\rSrSrSr\"5r\"5rSrSR\ R5r Sr SrSrSrSr\R&"5(aS \-rS rS r\R.\R2S S S .\R.\R2S SS .\R.\R2S SS .\R.\R4S S S .\R.\R4S SS .\R.\R4S SS .\\R4SSS .\R:S SS SS.\R:S SSSS.S. r\SS.\SS.\ SS.\ SS.\!SS.\!SS.\"S S.\"SS.S.r#0S\$_S\$_S\$_S\$_S\$_S\$_S\%_S\%_S \&_S!\&_S"\&_S#\&_S$\&_S%\&_S&\'_S'\'_r(\)\*\+\,\-\.\/\0\1\2\3\4S(. r5\R&"5(a\\5S)'\6\74\6\74S*S+.r8S,r9S-r:\;\\?S15r@\?S25rA\?S35rB\?S45rC\?S55rD\?S65rES7rFS8rGS9rHSS:jrIS*S;jrJS*S<jrKS=rLS>rM\NSS?j5rOS@rPSArQSBrRSSCjrSSSDjrTSErUSFrVSSGjrWSSHjrXSIrYSJrZSSKjr[SLr\SMr]SSNjr^SSOjr_SSPjr`SQraSRrbSSrcSTrdSUreSVrfSSWjrgSSXjrhSSYjriSSZjrjS[rkS\rlS]rmS^rnS_roS`rpSSajrqSbrrScrsSdrtSeruSfrvSgrwShrxSirySjrzSkr{Slr|Smr}SSnjr~SorSprSqrSrrSsrStrSurSvrSwrSxrSyrSzrSS{jrS|rS}rS~rSrSrSrSrSrSrSrSrSrSrSrSrSr\\GR<\\GR@\\GRD\\GRH\\GRL\\GRP\\GRT\\GRX0rSrg,) Transportah An SSH Transport attaches to a stream (usually a socket), negotiates an encrypted session, authenticates, and then creates stream tunnels, called `channels <.Channel>`, across the session. Multiple channels can be multiplexed across a single session (and often are, in the case of port forwardings). Instances of this class may be used as context managers. 2.0z paramiko_{}) z aes128-ctrz aes192-ctrz aes256-ctrz aes128-cbcz aes192-cbcz aes256-cbcz3des-cbczaes128-gcm@openssh.comzaes256-gcm@openssh.com) hmac-sha2-256 hmac-sha2-512hmac-sha2-256-etm@openssh.comhmac-sha2-512-etm@openssh.com hmac-sha1hmac-md5 hmac-sha1-96 hmac-md5-96) ssh-ed25519ecdsa-sha2-nistp256ecdsa-sha2-nistp384ecdsa-sha2-nistp521 rsa-sha2-512 rsa-sha2-256ssh-rsassh-dss) ecdh-sha2-nistp256ecdh-sha2-nistp384ecdh-sha2-nistp521diffie-hellman-group16-sha512$diffie-hellman-group-exchange-sha256diffie-hellman-group14-sha256"diffie-hellman-group-exchange-sha1diffie-hellman-group14-sha1diffie-hellman-group1-sha1)curve25519-sha256@libssh.org)%gss-gex-sha1-toWM5Slw5Ew8Mqkay+al2g==)gss-group14-sha1-toWM5Slw5Ew8Mqkay+al2g==(gss-group1-sha1-toWM5Slw5Ew8Mqkay+al2g==none)classmode block-sizekey-size  T)rriv-sizeris_aead)rsize@)rvrxrrrtrsrurwryrzssh-rsa-cert-v01@openssh.comrz!rsa-sha2-256-cert-v01@openssh.comr~z!rsa-sha2-512-cert-v01@openssh.comrzssh-dss-cert-v01@openssh.comr{z(ecdsa-sha2-nistp256-cert-v01@openssh.comr|z(ecdsa-sha2-nistp384-cert-v01@openssh.comr}z(ecdsa-sha2-nistp521-cert-v01@openssh.comrzz ssh-ed25519-cert-v01@openssh.com) rrrrrrrrrrrrr)NNzlib@openssh.comzlibrN皙?Fc  SUlSUl0UlXlSUl[ U[ 5(aFURSS5n U SUl[U 5S:XaU SS4nOU S[U S54n[U5[LaUupXlSn [R"X[R[R5nUHYunnnnnU[R:XdMUn[R"U[R5nUR!X45 O [%SR'X55e[(R*R-U5 S UlXlUR0R3UR45 U =(d [6"U5UlS UR:-S -UR<-UlS Ul S =Ul!Ul"S=Ul#Ul$S=Ul%Ul&S=Ul'Ul(SUl)SUl*SUl+X@l,SUl-SUl.SUl/URX(a/[aS U5Ul.URbURd-Ul2SUl3SUl4SUl5SUl6SUl7SUl8[5Ul9[(Rt"5Ul;[y5Ul=0Ul>0Ul?SUl@X0lAX lBSUlCSUlDSUlESUlF[(R"5UlH[(Rt"5UlISUlJSUlK[R"UR5UlNUR8RUR5 SUlPSUlQSUlRSUlSSUlTSUlUSUlVU=(d 0UlWXplXSUlYSUlZ0Ul[/Ul\[(R"URv5Ul^0Ul_[UR[UR[UR[UR[UR[UR[UR[UR[UR0 Ulrg![R"an[ U5n SnAGM-SnAff=f)aM Create a new SSH session over an existing socket, or socket-like object. This only creates the `.Transport` object; it doesn't begin the SSH session yet. Use `connect` or `start_client` to begin a client session, or `start_server` to begin a server session. If the object is not actually a socket, it must have the following methods: - ``send(bytes)``: Writes from 1 to ``len(bytes)`` bytes, and returns an int representing the number of bytes written. Returns 0 or raises ``EOFError`` if the stream has been closed. - ``recv(int)``: Reads from 1 to ``int`` bytes and returns them as a string. Returns 0 or raises ``EOFError`` if the stream has been closed. - ``close()``: Closes the socket. - ``settimeout(n)``: Sets a (float) timeout on I/O operations. For ease of use, you may also pass in an address (as a tuple) or a host string as the ``sock`` argument. (A host string is a hostname with an optional port (separated by ``":"``) which will be converted into a tuple of ``(hostname, port)``.) A socket will be connected to this address and used for communication. Exceptions from the ``socket`` call may be thrown in this case. .. note:: Modifying the the window and packet sizes might have adverse effects on your channels created from this transport. The default values are the same as in the OpenSSH code base and have been battle tested. :param socket sock: a socket or socket-like object to create the session over. :param int default_window_size: sets the default window size on the transport. (defaults to 2097152) :param int default_max_packet_size: sets the default max packet size on the transport. (defaults to 32768) :param bool gss_kex: Whether to enable GSSAPI key exchange when GSSAPI is in play. Default: ``False``. :param bool gss_deleg_creds: Whether to enable GSSAPI credential delegation when GSSAPI is in play. Default: ``True``. :param dict disabled_algorithms: If given, must be a dictionary mapping algorithm type to an iterable of algorithm identifiers, which will be disabled for the lifetime of the transport. Keys should match the last word in the class' builtin algorithm tuple attributes, such as ``"ciphers"`` to disable names within ``_preferred_ciphers``; or ``"kex"`` to disable something defined inside ``_preferred_kex``. Values should exactly match members of the matching attribute. For example, if you need to disable ``diffie-hellman-group16-sha512`` key exchange (perhaps because your code talks to a server which implements it differently from Paramiko), specify ``disabled_algorithms={"kex": ["diffie-hellman-group16-sha512"]}``. :param bool server_sig_algs: Whether to send an extra message to compatible clients, in server mode, with a list of supported pubkey algorithms. Default: ``True``. :param bool strict_kex: Whether to advertise (and implement, if client also advertises support for) a "strict kex" mode for safer handshaking. Default: ``True``. :param packetizer_class: Which class to use for instantiating the internal packet handler. Default: ``None`` (i.e.: use `Packetizer` as normal). .. versionchanged:: 1.15 Added the ``default_window_size`` and ``default_max_packet_size`` arguments. .. versionchanged:: 1.15 Added the ``gss_kex`` and ``gss_deleg_creds`` kwargs. .. versionchanged:: 2.6 Added the ``disabled_algorithms`` kwarg. .. versionchanged:: 2.9 Added the ``server_sig_algs`` kwarg. .. versionchanged:: 3.4 Added the ``strict_kex`` kwarg. .. versionchanged:: 3.4 Added the ``packetizer_class`` kwarg. FN:rzNo suitable address familyzUnable to connect to {}: {}TSSH--z gssapi-keyexg>@zparamiko.transporti)sactivehostnameserver_extensionsadvertise_strict_kexagreed_on_strict_kex isinstancestrsplitleninttypetuplesocket getaddrinfo AF_UNSPEC SOCK_STREAMconnecterrorraformat threadingThread__init__daemonsock settimeout_active_check_timeoutrU packetizer _PROTO_ID _CLIENT_ID local_versionremote_version local_cipher remote_cipherlocal_kex_initremote_kex_init local_mac remote_maclocal_compressionremote_compression session_id host_key_typehost_key use_gss_kex gss_kex_used kexgss_ctxtgss_hostr_preferred_gsskex_preferred_kex kex_engineHKinitial_kex_donein_kex authenticated_expected_packetLocklock ChannelMap _channelschannel_events channels_seen_channel_counterdefault_max_packet_sizedefault_window_size_forward_agent_handler _x11_handler _tcp_handlersaved_exceptionEvent clear_to_sendclear_to_send_lockclear_to_send_timeoutlog_namer get_loggerloggerset_log auth_handlerglobal_responsecompletion_eventbanner_timeouthandshake_timeout auth_timeoutchannel_timeoutdisabled_algorithmsserver_sig_algs server_mode server_objectserver_key_dictserver_accepts Conditionserver_accept_cvsubsystem_tabler@_parse_ext_infor _parse_newkeysr(_parse_global_requestr)_parse_request_successr*_parse_request_failurer-_parse_channel_open_successr._parse_channel_open_failurer/_parse_channel_openr_negotiate_keys_handler_table)selfrrrgss_kexgss_deleg_credsrr strict_kexpacketizer_classhlrportreason addrinfosfamilysocktypeproto canonnamesockaddrafes rkrTransport.__init__lsaF  !#$.!$)! dC C#BqEDM2w!|1r{1s2a5z* : !NH$M1F** 0 0&2D2DIAJ<%Hv111B!==V-?-?@D h%56AJ#188J !!$'   T778,9z94@#dnn4s:T__L 133D.599d2+//;??!8! #!   &~GD "&"8"84;N;N"ND  % " %NN$ $  !'>$#6 &*#  #&__."+.."2%)", oodmm4   , # $ "$&#6#<" .!!!  ) 3 3DII >! $.. ,,  : : !# UH)nUTRRT/5;dM%Uv M+ g7frg)rget).0xrtype_s rk .Transport._filter_algorithm..[s5 0044UB?? As$4 4)getattrrr)rr(defaults`` rk_filter_algorithmTransport._filter_algorithmYs4$ 6 6u =>    rmc$URS5$)Nciphersr-rs rkpreferred_ciphersTransport.preferred_ciphersa%%i00rmc$URS5$)Nmacsr1r2s rkpreferred_macsTransport.preferred_macses%%f--rmc`URS5n[U[SU55-5$)Nkeysc3D# UHnSRU5v M g7f)z{}-cert-v01@openssh.comN)r)r&r's rkr)+Transport.preferred_keys..rsJA-44Q77s )r-r)rfiltereds rkpreferred_keysTransport.preferred_keysis8 ))&1 JJJ K  rmc$URS5$)Npubkeysr1r2s rkpreferred_pubkeysTransport.preferred_pubkeysur5rmc$URS5$)Nkexr1r2s rk preferred_kexTransport.preferred_kexys%%e,,rmc$URS5$)N compressionr1r2s rkpreferred_compressionTransport.preferred_compression}s%%m44rmc[[U5[-5nSRU5nUR(dUS- nOUR S:wa<USRUR UR UR SS-5- nUR5(a(USR[UR55- nOUR(aUS- nOUS - nUS - nU$) @ Returns a string representation of this object, for debugging. z) hexidrrrr _cipher_infois_authenticatedrrr)rid_outs rk__repr__Transport.__repr__s"T(Y&')005{{ # #C  B&077%%%%d&7&78DqH$$&&6=='&&44& s  rmcXURR5 UR5 g)an Terminate this Transport without closing the session. On posix systems, if a Transport is open during process forking, both parent and child will share the underlying socket, but only one process can use the connection (without corrupting the session). Use this method to clean up a Transport object without disrupting the other process. .. versionadded:: 1.5.3 N)rcloser2s rkatforkTransport.atforks  rmc[U5$)z Return a `.SecurityOptions` object which can be used to tweak the encryption algorithms this transport will permit (for encryption, digest/hash operations, public keys, and key exchanges) and the order of preference for them. )SecurityOptionsr2s rkget_security_optionsTransport.get_security_optionsst$$rmc~U(dgUc URnU(aUb[R"U5nXlg)am Normalize/canonicalize ``self.gss_host`` depending on various factors. :param str gss_host: The explicitly requested GSS-oriented hostname to connect to (i.e. what the host's name is in the Kerberos database.) Defaults to ``self.hostname`` (which will be the 'real' target hostname and/or host portion of given socket object.) :param bool trust_dns: Indicates whether or not DNS is trusted; if true, DNS will be used to canonicalize the GSS hostname (which again will either be ``gss_host`` or the transport's default hostname.) (Defaults to True due to backwards compatibility.) :param bool gssapi_requested: Whether GSSAPI key exchange or authentication was even requested. If not, this is a no-op and nothing happens (and ``self.gss_host`` is not set.) (Defaults to True due to backwards compatibility.) :returns: ``None``. N)rrgetfqdnr)rr trust_dnsgssapi_requesteds rk set_gss_hostTransport.set_gss_hosts6,   }}H -~~h/H rmcSUlUbXlUR5 g[R"5=UlnUR5 Ub[ R "5U-OSnUR S5 UR(d UR5nUbUe[S5eUR5(dUb[ R "5U:agMv)a Negotiate a new SSH2 session as a client. This is the first step after creating a new `.Transport`. A separate thread is created for protocol negotiation. If an event is passed in, this method returns immediately. When negotiation is done (successful or not), the given ``Event`` will be triggered. On failure, `is_active` will return ``False``. (Since 1.4) If ``event`` is ``None``, this method will not return until negotiation is done. On success, the method returns normally. Otherwise an SSHException is raised. After a successful negotiation, you will usually want to authenticate, calling `auth_password ` or `auth_publickey `. .. note:: `connect` is a simpler method for connecting as a client. .. note:: After calling this method (or `start_server` or `connect`), you should no longer directly read from or write to the original socket object. :param .threading.Event event: an event to trigger when negotiation is complete (optional) :param float timeout: a timeout, in seconds, for SSH2 session negotiation (optional) :raises: `.SSHException` -- if negotiation fails (and no ``event`` was passed in) TNrNegotiation failed.) rrstartrrtimewait get_exceptionrais_set)reventtimeoutmax_timer!s rk start_clientTransport.start_clientsF  $) ! JJL )2(99 ,3,?499;(T JJsO;;&&(=G"#899||~~# x(?rmcUc [5nSUlX lSUlUbXlUR 5 g[ R"5=UlnUR 5 URS5 UR(d UR5nUbUe[S5eUR5(agMZ)ah Negotiate a new SSH2 session as a server. This is the first step after creating a new `.Transport` and setting up your server host key(s). A separate thread is created for protocol negotiation. If an event is passed in, this method returns immediately. When negotiation is done (successful or not), the given ``Event`` will be triggered. On failure, `is_active` will return ``False``. (Since 1.4) If ``event`` is ``None``, this method will not return until negotiation is done. On success, the method returns normally. Otherwise an SSHException is raised. After a successful negotiation, the client will need to authenticate. Override the methods `get_allowed_auths <.ServerInterface.get_allowed_auths>`, `check_auth_none <.ServerInterface.check_auth_none>`, `check_auth_password <.ServerInterface.check_auth_password>`, and `check_auth_publickey <.ServerInterface.check_auth_publickey>` in the given ``server`` object to control the authentication process. After a successful authentication, the client should request to open a channel. Override `check_channel_request <.ServerInterface.check_channel_request>` in the given ``server`` object to allow channels to be opened. .. note:: After calling this method (or `start_client` or `connect`), you should no longer directly read from or write to the original socket object. :param .threading.Event event: an event to trigger when negotiation is complete. :param .ServerInterface server: an object used to perform authentication and create `channels <.Channel>` :raises: `.SSHException` -- if negotiation fails (and no ``event`` was passed in) NTrrg) rZrrrrrhrrrjrkrarl)rrmserverr!s rk start_serverTransport.start_server sT >$&F#  $) ! JJL )2(99  JJsO;;&&(=G"#899||~~rmcXRUR5'[U[5(aXRS'XRS'gg)a Add a host key to the list of keys used for server mode. When behaving as a server, the host key is used to sign certain packets during the SSH2 negotiation, so that the client can trust that we are who we say we are. Because this is used for signing, the key must contain private key info, not just the public half. Only one key of each type (RSA or DSS) is kept. :param .PKey key: the host key to add, usually an `.RSAKey` or `.DSSKey`. rr~N)rget_namerrX)rkeys rkadd_server_keyTransport.add_server_keyNsH03S\\^, c6 " "36  036  0 #rmcVURUR$![a gf=f)a Return the active host key, in server mode. After negotiating with the client, this method will return the negotiated host key. If only one type of host key was set with `add_server_key`, that's the only key that will ever be returned. But in cases where you have set more than one type of host key (for example, an RSA key and a DSS key), the key type will be negotiated by the client, and this method will return the key of the type agreed on. If the host key has not been negotiated yet, ``None`` is returned. In client mode, the behavior is undefined. :return: host key (`.PKey`) of the type negotiated by the client, or ``None``. N)rrKeyErrorr2s rkget_server_keyTransport.get_server_keybs3 ''(:(:; ;   s  ((c[5[lSS/nUbURSU5 UH#n[RR U5 g S[lg![ a M@f=f)a (optional) Load a file of prime moduli for use in doing group-exchange key negotiation in server mode. It's a rather obscure option and can be safely ignored. In server mode, the remote client may request "group-exchange" key negotiation, which asks the server to send a random prime number that fits certain criteria. These primes are pretty difficult to compute, so they can't be generated on demand. But many systems contain a file of suitable primes (usually named something like ``/etc/ssh/moduli``). If you call `load_server_moduli` and it returns ``True``, then this file of primes has been loaded and we will support "group-exchange" in server mode. Otherwise server mode will just claim that it doesn't support that method of key negotiation. :param str filename: optional path to the moduli file, if you happen to know that it's not in a standard location. :return: True if a moduli file was successfully loaded; False otherwise. .. note:: This has no effect when used in client mode. z/etc/ssh/moduliz/usr/local/etc/moduliNrTF)rWro _modulus_packinsert read_fileIOError)filename file_listfns rkload_server_moduliTransport.load_server_moduliwsv4#.- &(?@     Q )B ''11"5#'    sA"" A0/A0cUR(dgUR5 [URR 55HnUR 5 M UR R5 g)z@ Close this session, and any open channels that are tied to it. N)rrilistrvalues_unlinkrrY)rchans rkrYTransport.closesM{{  ..01D LLN2 rmctUR(aUR(d [S5eUR$)at Return the host key of the server (in client mode). .. note:: Previously this call returned a tuple of ``(key type, key string)``. You can get the same effect by calling `.PKey.get_name` for the key type, and ``str(key)`` for the key string. :raises: `.SSHException` -- if no session is currently active. :return: public key (`.PKey`) of the remote server No existing session)rrrarr2s rkget_remote_server_keyTransport.get_remote_server_keys) T%:%:45 5}}rmcUR$)z Return true if this session is active (open). :return: True if the session is still active (open); False if the session is closed )rr2s rk is_activeTransport.is_actives{{rmc&URSUUUS9$)a  Request a new channel to the server, of type ``"session"``. This is just an alias for calling `open_channel` with an argument of ``"session"``. .. note:: Modifying the the window and packet sizes might have adverse effects on the session created. The default values are the same as in the OpenSSH code base and have been battle tested. :param int window_size: optional window size for this session. :param int max_packet_size: optional max packet size for this session. :return: a new `.Channel` :raises: `.SSHException` -- if the request is rejected or the session ends prematurely .. versionchanged:: 1.13.4/1.14.3/1.15.3 Added the ``timeout`` argument. .. versionchanged:: 1.15 Added the ``window_size`` and ``max_packet_size`` arguments. session) window_sizemax_packet_sizern open_channel)rrrrns rk open_sessionTransport.open_sessions(8  #+ !  rmc"URSUS9$)aq Request a new channel to the client, of type ``"x11"``. This is just an alias for ``open_channel('x11', src_addr=src_addr)``. :param tuple src_addr: the source address (``(str, int)``) of the x11 server (port is the x11 port, ie. 6010) :return: a new `.Channel` :raises: `.SSHException` -- if the request is rejected or the session ends prematurely x11)src_addrr)rrs rkopen_x11_channelTransport.open_x11_channels   ::rmc$URS5$)a  Request a new channel to the client, of type ``"auth-agent@openssh.com"``. This is just an alias for ``open_channel('auth-agent@openssh.com')``. :return: a new `.Channel` :raises: `.SSHException` -- if the request is rejected or the session ends prematurely auth-agent@openssh.comrr2s rkopen_forward_agent_channel$Transport.open_forward_agent_channels  !9::rmc&URSX!5$)a Request a new channel back to the client, of type ``forwarded-tcpip``. This is used after a client has requested port forwarding, for sending incoming connections back to the client. :param src_addr: originator's address :param dest_addr: local (server) connected address forwarded-tcpipr)rr dest_addrs rkopen_forwarded_tcpip_channel&Transport.open_forwarded_tcpip_channels  !2IHHrmcUR(d [S5eUc UROUnURR 5 UR U5nUR U5nUR5n[5nUR[5 URU5 URU5 URU5 URU5 US:XdUS:XaQURUS5 URUS5 URUS5 URUS5 O.US:Xa(URUS5 URUS5 [U5n URRXy5 [ R""5=UR$U'n SUR&U'U R)U5 U R+XE5 URR-5 UR/U5 [0R0"5n U R3S5 UR(d UR55n U c [S 5n U eU R75(aO(X-[0R0"5:a [S 5eMURR9U5n U bU $UR55n U c [S 5n U e!URR-5 f=f) a Request a new channel to the server. `Channels <.Channel>` are socket-like objects used for the actual transfer of data across the session. You may only request a channel after negotiating encryption (using `connect` or `start_client`) and authenticating. .. note:: Modifying the the window and packet sizes might have adverse effects on the channel created. The default values are the same as in the OpenSSH code base and have been battle tested. :param str kind: the kind of channel requested (usually ``"session"``, ``"forwarded-tcpip"``, ``"direct-tcpip"``, or ``"x11"``) :param tuple dest_addr: the destination address (address + port tuple) of this port forwarding, if ``kind`` is ``"forwarded-tcpip"`` or ``"direct-tcpip"`` (ignored for other channel types) :param src_addr: the source address of this port forwarding, if ``kind`` is ``"forwarded-tcpip"``, ``"direct-tcpip"``, or ``"x11"`` :param int window_size: optional window size for this session. :param int max_packet_size: optional max packet size for this session. :param float timeout: optional timeout opening a channel, default 3600s (1h) :return: a new `.Channel` on success :raises: `.SSHException` -- if the request is rejected, the session ends prematurely or there is a timeout opening a channel .. versionchanged:: 1.15 Added the ``window_size`` and ``max_packet_size`` arguments. SSH session not activer direct-tcpiprrrTrzUnable to open channel.zTimeout opening channel.)rrarracquire_sanitize_window_size_sanitize_packet_size _next_channelrTadd_byter add_stringadd_intrrputrrrr_set_transport _set_windowrelease_send_user_messagerirjrkrlr%) rkindrrrrrnchanidmrrmstart_tsr!s rkrTransport.open_channelssX{{78 8*1/$&&w  44[AK"88IO'')F A JJ( ) LL  IIf  IIk " IIo &))t~/E Yq\* )A,' Xa[) (1+& Xa[) (1+&6?D NN  v ,2;//2C CD   '%)-D  v &    %   [ : II    "99; JJsO;;&&(9$%>?A||~~#diik1"#=>>~~!!&)  K     967A) II   s FK%%Lc^TR(d [S5e[U5nTRSX4SS9nUc [S5eUS:XaUR 5nUcU4SjnUnUTlU$)a Ask the server to forward TCP connections from a listening port on the server, across this SSH session. If a handler is given, that handler is called from a different thread whenever a forwarded connection arrives. The handler parameters are:: handler( channel, (origin_addr, origin_port), (server_addr, server_port), ) where ``server_addr`` and ``server_port`` are the address and port that the server was listening on. If no handler is set, the default behavior is to send new incoming forwarded connections into the accept queue, to be picked up via `accept`. :param str address: the address to bind when forwarding :param int port: the port to forward, or 0 to ask the server to allocate any port :param callable handler: optional handler for incoming forwarded connections, of the form ``func(Channel, (str, int), (str, int))``. :return: the port number (`int`) allocated by the server :raises: `.SSHException` -- if the server refused the TCP forward request r tcpip-forwardTrjzTCP forwarding request deniedrc(>TRU5 grg_queue_incoming_channel)channelrdest_addr_portrs rkdefault_handler7Transport.request_port_forward..default_handlers,,W5rm)rrarglobal_requestget_intr)raddressrhandlerresponsers` rkrequest_port_forwardTransport.request_port_forwardrsB{{78 84y&& g_4'   >? ? 19##%D ? 6 &G# rmcZUR(dgSUlURSX4SS9 g)z Ask the server to cancel a previous port-forwarding request. No more connections to the given address & port will be forwarded across this ssh connection. :param str address: the address to stop forwarding :param int port: the port to stop forwarding Ncancel-tcpip-forwardTr)rrr)rrrs rkcancel_port_forwardTransport.cancel_port_forwards.{{   2WO$Ormc.[R"U5$)a  Create an SFTP client channel from an open transport. On success, an SFTP session will be opened with the remote host, and a new `.SFTPClient` object will be returned. :return: a new `.SFTPClient` referring to an sftp session (channel) across this transport )r[from_transportr2s rkopen_sftp_clientTransport.open_sftp_clients((..rmc[5nUR[5 Uc%[[R "S55S-S-nUR [R "U55 URU5 g)aq Send a junk packet across the encrypted link. This is sometimes used to add "noise" to a connection to confuse would-be attackers. It can also be used as a keep-alive for long lived connections traversing firewalls. :param int byte_count: the number of random bytes to send in the payload of the ignored packet -- defaults to a random number from 10 to 41. Nrr )rTrrrBosurandom add_bytesr)r byte_countrs rk send_ignoreTransport.send_ignores\ I ;  "2::a=1B6"._requests##$7e#D DrmN)weakrefproxyr set_keepalive)rintervalrs rkrTransport.set_keepalives*}}T* E %%h9rmcU(a[R"5Ul[5nUR [ 5 UR U5 URU5 UbUR"U6 UR[SRU55 URU5 U(dgURRS5 UR(dgURR5(a UR $M[)a Make a global request to the remote host. These are normally extensions to the SSH2 protocol. :param str kind: name of the request. :param tuple data: an optional tuple containing additional data to attach to the request. :param bool wait: ``True`` if this method should not return until a response is received; ``False`` otherwise. :return: a `.Message` containing possible additional data if the request was successful (or an empty `.Message` if ``wait`` was ``False``); ``None`` if the request was denied. NzSending global request "{}"r)rrrrTrrr add_booleanadd_logrrrrjrrlr)rrdatarjrs rkrTransport.global_requests" $-OO$5D ! I &' T d   EE4L %6==dCD "  ! ! & &s +;;$$++--### rmcURR5 [UR5S:aURR S5nORUR R U5 [UR5S:aURR S5nOSnURR5 U$!URR5 f=f)a Return the next channel opened by the client over this transport, in server mode. If no channel is opened before the given timeout, ``None`` is returned. :param int timeout: seconds to wait for a channel, or ``None`` to wait forever :return: a new `.Channel` opened by the client rN)rrrrpoprrjr)rrnrs rkacceptTransport.accept$s  4&&'!+**..q1%%**73t**+a/..2215D D II     II   s BB??Cc Ub5[U[5(a /SQUlOUR5/UlUR UU U=(d US9 UR 5 UGbFU(Gd>UR 5n U R5UR5:wd"U R5UR5:waUR[S5 UR[SRUR5[UR5555 UR[SRU R5[U R5555 [S5eUR[SRUR555 UcUcU(dU(aU(a3UR[S5 URX RU5 gU(a(UR[S 5 URU5 gUb(UR[S 5 UR!X$5 gUR[S 5 UR#X#5 g) a Negotiate an SSH2 session, and optionally verify the server's host key and authenticate using a password or private key. This is a shortcut for `start_client`, `get_remote_server_key`, and `Transport.auth_password` or `Transport.auth_publickey`. Use those methods if you want more control. You can use this method immediately after creating a Transport to negotiate encryption with a server. If it fails, an exception will be thrown. On success, the method will return cleanly, and an encrypted session exists. You may immediately call `open_channel` or `open_session` to get a `.Channel` object, which is used for data transfer. .. note:: If you fail to supply a password or private key, this method may succeed, but a subsequent `open_channel` or `open_session` call may fail because you haven't authenticated yet. :param .PKey hostkey: the host key expected from the server, or ``None`` if you don't want to do host key verification. :param str username: the username to authenticate as. :param str password: a password to use for authentication, if you want to use password authentication; otherwise ``None``. :param .PKey pkey: a private key to use for authentication, if you want to use private key authentication; otherwise ``None``. :param str gss_host: The target's name in the kerberos database. Default: hostname :param bool gss_auth: ``True`` if you want to use GSS-API authentication. :param bool gss_kex: Perform GSS-API Key Exchange and user authentication. :param bool gss_deleg_creds: Whether to delegate GSS-API client credentials. :param gss_trust_dns: Indicates whether or not the DNS is trusted to securely canonicalize the name of the host being connected to (default ``True``). :raises: `.SSHException` -- if the SSH2 negotiation fails, the host key supplied by the server is incorrect, or authentication fails. .. versionchanged:: 2.3 Added the ``gss_trust_dns`` argument. N)r~rr)rrbrczBad host key from serverzExpected: {}: {}zGot : {}: {}zHost key verified ({})z,Attempting GSS-API auth... (gssapi-with-mic)z)Attempting GSS-API auth... (gssapi-keyex)zAttempting public-key auth...zAttempting password auth...)rrX_preferred_keysrwrdrprasbytesrrrreprraauth_gssapi_with_micrauth_gssapi_keyexauth_publickey auth_password) rhostkeyusernamepasswordpkeyrgss_authrr gss_trust_dnsrxs rkrTransport.connect=sx  '6**($ )0(8(8(:';$ #$0    ,,.C '"2"2"44;;=GOO$55 %!;< &--((*D1B,C  &-- S[[](; ##=>> II/66w7G7G7IJ   ("68w I))mm_  %!LM&&x0 ! %!@A##H3  %!>?""86rmcURR5 URnSUlUURR5 $!URR5 f=f)a9 Return any exception that happened during the last server request. This can be used to fetch more specific error information after using calls like `start_client`. The exception (if any) is cleared after this call. :return: an exception, or ``None`` if there is no stored exception. .. versionadded:: 1.1 N)rrrrrs rkrkTransport.get_exceptionsP  $$A#'D  II   DII    A A'cURR5 X#U4URU'URR5 g!URR5 f=f)a Set the handler class for a subsystem in server mode. If a request for this subsystem is made on an open ssh channel later, this handler will be constructed and called -- see `.SubsystemHandler` for more detailed documentation. Any extra parameters (including keyword arguments) are saved and passed to the `.SubsystemHandler` constructor later. :param str name: name of the subsystem. :param handler: subclass of `.SubsystemHandler` that handles this subsystem. Nrrrr)rnamerargskwargss rkset_subsystem_handlerTransport.set_subsystem_handlersM II   *1)@D  & II   DII   s +AA$cUR=(a/ URSL=(a URR5$)z Return true if this session is active and authenticated. :return: True if the session is still open and has been authenticated successfully; False if authentication failed and/or the session is closed. N)rrrSr2s rkrSTransport.is_authenticateds: KK 5!!- 5!!224 rmctUR(a URcgURR5$)z Return the username this connection is authenticated for. If the session is not authenticated (or authentication failed), this method returns ``None``. :return: username that was authenticated (a `str`), or ``None``. N)rr get_usernamer2s rkrTransport.get_usernames.{{t008  --//rmclUR(a URcgURR$)z Return the banner supplied by the server upon connect. If no banner is supplied, this method returns ``None``. :returns: server supplied banner (`str`), or ``None``. .. versionadded:: 1.13 N)rrbannerr2s rk get_bannerTransport.get_banners+{{t008  '''rmcUR(aUR(d [S5e[R"5n[ U5UlUR RX5 UR RU5$)at Try to authenticate to the server using no authentication at all. This will almost always fail. It may be useful for determining the list of authentication types supported by the server, by catching the `.BadAuthenticationType` exception raised. :param str username: the username to authenticate as :return: list of auth types permissible for the next stage of authentication (normally empty) :raises: `.BadAuthenticationType` -- if "none" authentication isn't allowed by the server for this user :raises: `.SSHException` -- if the authentication failed due to a network error .. versionadded:: 1.5 r) rrrarrr r auth_nonewait_for_responserrmy_events rkrTransport.auth_none sc* T%:%:45 5??$'- ##H7  228<[U5S:a [S5e[U5S:Xa/$T/$NrzFallback authentication failed.rrratitle instructionsfieldsrs rkr(Transport.auth_password..handlern56{Q*+LMM6{a' " $:%rm) rrrarrr rrrr\ allowed_typesauth_interactive)rrrrmfallbackrr!rs ` rkrTransport.auth_password)s^ T%:%:45 5 = (HH'- ''(HE  I $$66x@ @$  6aoo M  &,,X??  ' s0=B C,"C';CC, C$$C''C,c*UR(aUR(d [S5eUc[R"5nOUn[ U5UlUR RXU5 Ub/$UR RU5$)a Authenticate to the server using a private key. The key is used to sign data from the server, so it must include the private part. If an ``event`` is passed in, this method will return immediately, and the event will be triggered once authentication succeeds or fails. On success, `is_authenticated` will return ``True``. On failure, you may use `get_exception` to get more detailed error information. Since 1.1, if no event is passed, this method will block until the authentication succeeds or fails. On failure, an exception is raised. Otherwise, the method simply returns. If the server requires multi-step authentication (which is very rare), this method will return a list of auth types permissible for the next step. Otherwise, in the normal case, an empty list is returned. :param str username: the username to authenticate as :param .PKey key: the private key to authenticate with :param .threading.Event event: an event to trigger when the authentication attempt is complete (whether it was successful or not) :return: list of auth types permissible for the next stage of authentication (normally empty) :raises: `.BadAuthenticationType` -- if public-key authentication isn't allowed by the server for this user (and no event was passed in) :raises: `.AuthenticationException` -- if the authentication failed (and no event was passed in) :raises: `.SSHException` -- if there was a network error r) rrrarrr rrr)rrrxrmrs rkrTransport.auth_publickey~s{F T%:%:45 5 = (HH'- ((A  I  228<.handler^%++-(,,,./*5&F&,,.c2NN57++6rm)r-rrrr3s rkauth_interactive_dumbTransport.auth_interactive_dumbs! $$X CCrmcUR(aUR(d [S5e[R"5n[ U5UlUR RXX45 UR RU5$)aD Authenticate to the Server using GSS-API / SSPI. :param str username: The username to authenticate as :param str gss_host: The target host :param bool gss_deleg_creds: Delegate credentials or not :return: list of auth types permissible for the next stage of authentication (normally empty) :raises: `.BadAuthenticationType` -- if gssapi-with-mic isn't allowed by the server (and no event was passed in) :raises: `.AuthenticationException` -- if the authentication failed (and no event was passed in) :raises: `.SSHException` -- if there was a network error r) rrrarrr rrr)rrrrrs rkrTransport.auth_gssapi_with_micsj  T%:%:45 5??$'- ..    228<($JD !**Fnn  (4"&!6!6!:h F rmc:URRU5 g)z?used by a Channel to remove itself from the active channel listN)rdeletervs rk_unlink_channelTransport._unlink_channels f%rmc:URRU5 grg)r send_message)rrs rk _send_messageTransport._send_messages $$T*rmcX[R"5nURRS5 UR(dUR [ S5 gUR R5 URR5(aOLUR R5 [R"5X R-:a [S5eMURU5 UR R5 g!UR R5 f=f)zc send a message, but block if we're in key negotiation. this is used for user-initiated requests. rz0Dropping user packet because connection is dead.Nz2Key-exchange timed out waiting for key negotiation) rirrjrrrrrrlrrrar~)rrrhs rkrTransport._send_user_messages      # #C (;; M  # # + + -!!((**  # # + + -yy{U%?%???"H .   t $  # # + + -D # # + + -s !D D)cDXlX lURcX lgg)zB Used by a kex obj to set the K (root key) and H (exchange hash). N)rrr)rkhs rk_set_K_HTransport._set_K_Hs" ?? "O #rmc$[U5Ulg)zG Used by a kex obj to register the next packet type it expects to see. N)rr)rptypess rk_expect_packetTransport._expect_packets!&f rmcURUR"[U55nUc [S5eUR UR [U55(d$[SR UR55eX0lg)NzUnknown host key typez#Signature verification ({}) failed.) _key_inforrTraverify_ssh_sigrrr)rrsigrxs rk _verify_keyTransport._verify_keyswnnT//01BC ;67 7!!$&&'#,775<<&&   rmc[5nURUR5 URUR5 UR [ U55 URUR5 [URSS5nSRURRRU5nUc [nUS- n[US5(d#UR[ U5 [#USS5 U"UR%55R'5=pg[)U5U:a[5nURUR5 URUR5 URU5 U"UR%55R'5nXh- nXx- n[)U5U:aMUSU$)z0id is 'A' - 'F' for the various keys used by ssh hash_algoNz&kex engine {} specified hash_algo {!r}z, falling back to sha1_logged_hash_selectionT)rT add_mpintrrrrrdrr+rr __class____name__rhasattrrrsetattrrdigestr) rrQnbytesrrhash_select_msgrUsofarrs rk _compute_keyTransport._compute_keysa I DFF DFF 1R5 DOO$DOO[$? BII OO % % . .    I 7 7Ot566 IIe_ - D2D 9 ,3355#h A KK  KK  KK qyy{+224F MC OE#h7F|rmcXR;a[SU-5eURUnUS"U5nU(aU$[UUS"U5[5S9nX@RLaUR 5$UR 5$)NzUnknown cipher rr) algorithmrbackend)rRrar r_ENCRYPT encryptor decryptor) rr rxiv operationr inforciphers rk _get_engineTransport._get_engines (( (0478 8  &M#&   fb!#%    %##% %##% %rmc6^UcU4SjnUTlgUTlg)Nc(>TRU5 grgr)rrs rkr=Transport._set_forward_agent_handler..default_handler,,W5rm)rrrrs` rk_set_forward_agent_handler$Transport._set_forward_agent_handlers ? 6+:D '*1D 'rmc6^UcU4SjnUTlgUTlg)Nc(>TRU5 grgr)r src_addr_portrs rkr3Transport._set_x11_handler..default_handler$rrm)rrs` rk_set_x11_handlerTransport._set_x11_handler s ? 6!0D  'D rmcURR5 URRU5 URR 5 URR 5 g!URR 5 f=frg)rrrr=rnotifyr)rrs rkr!Transport._queue_incoming_channel+s^     & &w /  ! ! ( ( * II   DII   s 5A,,BcJUc URn[[U[5$rg)rrcr8r:)rrs rkrTransport._sanitize_window_size3s"  22K?KIIrmcJUc URn[[U[5$rg)rrcr9r:)rrs rkrTransport._sanitize_packet_size8s"  ""::O?O_MMrmcUR(aU[::dUR5(ag[5nU[:XaUR [ 5 U$U[:Xa}UR5nUR5nUR [5 URU5 UR[5 URS5 URS5 U$)a? Checks message type against current auth state. If server mode, and auth has not succeeded, and the message is of a post-auth type (channel open or global request) an appropriate error response Message is crafted and returned to caller for sending. Otherwise (client mode, authed, or pre-auth message) returns None. Nren)rr=rSrTr(rr"r/get_textrr&rr$r)rptypemessagereplyrrs rk_ensure_authedTransport._ensure_authed=s  33$$&&  & & NN/ 0 & &##%D__&F NN4 5 MM& ! MMA B   R   T "  rmcUR(a<UR(d*[R"USU35n[ SU<S35egg)z Conditionally raise `MessageOrderError` during strict initial kex. This method should only be called inside code that handles non-KEXINIT messages; it does not interrogate ``ptype`` besides using it to log more accurately. zmsg z!In strict-kex mode, but was sent !N)rrr?r%r_)rrr s rk_enforce_strict_kexTransport._enforce_strict_kexcsM  $ $T-B-B==$ug7D#3D81= .C $rmc[Ul[RU5 [[ U5[ -5nUR (a&UR[SRU55 O%UR[SRU55 URR[URS-55 UR[SRUR55 UR5 URRUR 5 UR#5 UR%[&5 UR((Ga~URR+5(a!UR,(dUR#5 URR/5up#U[2:XaUR5U5 MU[6:XaUR9U5 GOU[::Xa$UR5U5 UR=U5 M[?UR@5S:aX R@;a?[BnURD(a[FnU"SRUR@U55e[I5Ul US:a$US::aURJRMX#5 GMwX RN;aBURQX#5nU(aURSU5 GOURNU"U5 GOX RT;aURW5nURXR[U5nUbURTU"Xs5 GOFX`R\;a'UR[S RU55 GOUR[^S RU55 GOUR`bWX R`RN;a>UR`RNUnU"U5 [?UR@5S:aGMO[bUn S RX)5n UR[dU 5 U[f:waK[i5n U Rk[l5 U RoURp5 URSU 5 URRs5 UR((aGM~[RU5 [URXR55HnUR5 M UR((aSUlURR5 URbURR5 UR`bUR`R5 URR5HnUR5 M URR5 URR5 URR5 URR5 g![0a GMf=f![Basn UR[^S RUR (aS OSU 55 UR[^[tRv"55 Xl<Sn A GNSn A f[za'n UR[S5 Xl<Sn A GN#Sn A f[|R~an [U R5[HLa\U R(a-SRU RSU RS5n O*[U 5=(d [U 5n O U Rn UR[^SU -5 Xl<Sn A GNSn A f[a\n UR[^S[U 5-5 UR[^[tRv"55 Xl<Sn A GNGSn A ff=f!URR5 f=f! URRbeg=f)Nz!starting thread (server mode): {}z!starting thread (client mode): {}z zLocal version/idstring: {}rz$Expecting packet from {!r}, got {:d}r)z&Ignoring message for dead channel {:d}z(Channel request for unknown channel {:d}zOops, unhandled type {} ({!r})zException ({}): {}rsclientzEOF in transport threadz {} ({:d})rzSocket exception: zUnknown exception: F)Usysrhr=rPrQrrrrrr write_allrdr _check_bannerstart_handshakerrrrr need_rekeyr read_messagerVrrr_parse_disconnectr _parse_debugrrrarr_rr parse_nextrrr~_channel_handler_tablerrr%rrrr?rr>rTrrrseqnocomplete_handshaker tb_stringsrEOFErrorrrrrrr ExceptionremoverrrrYrsetabortrrrrrrrmodules)rtidrr exc_class error_msgrrrr warningrpr!emsgrms rkrun Transport.runqsV t$"T(Y&'    IIe@GGL M IIe@GGL MY  )))!D,>,>,G*HI 0778J8JK""$//0F0FG##%##K0kkk1133DKK++-!#'??#?#?#A *007 .0..q1)+007))!, 4001A5 (=(==(4I#88,= "+ F M M$($9$95!"# 16-"RKerk OO66u@$ 3 33$($7$7$A $ ..y9 //6q9"="==!"#~~11&9+ 77>tG#'9'99 II % H O O$*!"!II % J Q Q$*!" "))5!%6%6%E%EE"&"3"3"B"B5"I t4459$: )/"B"I"I!# '73 $55"))CLL);<KK0 ..s3OO668gkkk\  " "4 (T^^2245 6{{# %%'((4))--/$$0%%++-!00779EIIK:(II%%'))002II%%' IIOO u.! !^  ) (//$($4$4(A  %!23'($$ ) %!:;'($$<< )<5(vv*11!&&)QVVAYG"1v0a66D %!5!<='($$ ) %!6Q!?@ %!23'($$ )(II%%'  xx+,sD Y 'Y8Y ;a=GY a DY $Da%4`34a YY YY `0*A([a `0%\a`0B#_a `0A`+%a+`00a3aaa.cSRU5nX#:XaXB- nOUSRX#5- nUR[U5 g)Nz{}: zlocal={}, remote={})rrr)rwhichlocalremoterps rk_log_agreementTransport._log_agreement sBmmE" ? LC (//> >C %rmcpURR5 URR5 URR 5 UR cUR 5 URU5 URR5 g!URR 5 f=frg) rrrclearrrr_parse_kex_initr start_kexrrs rkrTransport._negotiate_keys* s '') .    $ $ &  # # + + -    &    ! Q !!#  # # + + -s BB5c[S5HXnUS:Xa URnOSnURRU5nUSSS:Xa OUR[SU-5 MZ WSSS:wa[ SU-S -5eX0l UR[S RU55 URS 5nUS:aUSUnURS S5n[U5S :a [ S5eUSnUSnUS:wa"US:waSn[URU55eSRXg5nUR[ U5 g![a e[ an[ S[U5-5eSnAff=f)Ndrz!Error reading SSH protocol bannerrzBanner: z!Indecipherable protocol version ""zRemote version/idstring: {}r8rzInvalid SSH bannerrz1.99rqz(Incompatible version ({} instead of 2.0)z!Connected (version {}, client {}))rangerrreadliner`rrarrrrrfindrrr^r) rirnbufr!segsversionrrps rkrTransport._check_banner7 ssAAv-- oo..w72Aw&  IIeZ#- .#$ r7f BSH3NO O! %6==cBC HHSM 6bq'Cyya  t9q=34 4q'a f E!15 UR9UR>5 URA[C55 URA[C55 URES5 URGS5 URI5=Ul%Ul&UROU5 g!URR 5 f=fs snfs snf) zk announce to the other side that we'd like to negotiate keys, and what kind of key negotiation we support. FTz!diffie-hellman-group-exchange-shaNr ext-info-csc kex-strict--v00@openssh.comr)(rrrrrrrrrGr startswithrrr^rFfilterrr; __contains__r?r=rrTrrrrradd_listr3r8rKrbytesrrrr_latest_kex_initr~) r kex_algosmp_required_prefixrkex_mppkexavailable_server_keysrrs rkrTransport._send_kex_initb s '') .    $ $ &  # # + + -! ++,   !D !*OAll;M.NaFO""*Vq "668<<<<<(:;< 37))+/$(--2245BB''  % !%)$7$7 !   \ *  $ $++CE   {5'1AB C I <  BJJrN# 9 () 4))* 4))* 4&&' 4&&' 4--. 4--. UW UW e ! 67iikAd3 1{  # # + + - Ps#M M-'M-'M2M2M*c0nU(aUR5 URS5 UR5US'UR5US'UR5US'UR5US'UR5US'UR5US'UR5US'UR5US 'UR5US 'UR5US 'UR5US 'UR 5 U$) Nr kex_algo_listserver_key_algo_listclient_encrypt_algo_listserver_encrypt_algo_listclient_mac_algo_listserver_mac_algo_listclient_compress_algo_listserver_compress_algo_listclient_lang_listserver_lang_list kex_follows)get_byte get_bytesget_list get_booleanr)rrignore_first_byteparseds rk_really_parse_kex_init Transport._really_parse_kex_init s  JJL B"#**,)*%&-.ZZ\)*-.ZZ\)*)*%&)*%&./jjl*+./jjl*+%&ZZ\!"%&ZZ\!" ! }  rmcHUR[UR5SS9$)NT)r$)r&rTr r2s rk_get_latest_kex_initTransport._get_latest_kex_init s+** D)) *"+  rmc FURU5nUSnUSnUSnUSnUSnUSnUSn USn US n US n US n UR[S 5 S U4SU4SU4SU4SU4SU4SU 4SU 4SU 4SU 44 HEupUS/:XaS/nSRU5nUR[SR X55 MG UR[SR U 55 UR[S5 SUlSUl/n[U5HunnURS5(aUUlURSU5 M7URS5(dMOUR(aS OS!nSUS"3nUU:H=(a URUl UR[S#UR35 URSU5 M UHnURU5 M UR(a,UR(dURS:wa [!S$5eUR(a*[#[%UR&R(U55nO)[#[%UR(UR&55n[+U5S:Xa [-S%5eUR.US"U5UlUR[S&R US55 UR(aj[#[%[#UR2R555R(UR655n[#[%UR(U55nO)[#[%UR(UR655n[+U5S:Xa [-S'5eUSUlUR(aUR;5c [-S(5eUR=S)USUS5 UR(aS[#[%UR>R(U55n[#[%UR>R(U55nOR[#[%UR(UR>55n[#[%UR(UR>55n[+U5S:Xd[+U5S:Xa [-S*5eUSUl USUl!UR=S+UR@URBS,9 UR(aS[#[%URDR(U55n[#[%URDR(U55nOR[#[%UR(URD55n[#[%UR(URD55n[+U5S:Xd[+U5S:Xa [-S-5eUSUl#USUl$UR=S.URFURHS,9 UR(aS[#[%URJR(U 55n[#[%URJR(U 55nOR[#[%U R(URJ55n[#[%U R(URJ55n[+U5S:Xd[+U5S:Xa-S/nUS0- n[-UR UUURJ55eUSUl&USUl'UR=S1URLURNS,9 UR[S25 [PURS5-Ul*g)3Nrrrrrrrrrrrz"=== Key exchange possibilities ===z kex algosz server keyzclient encryptzserver encryptz client macz server maczclient compresszserver compressz client langz server langrzz, z{}: {}zkex follows: {}z=== Key exchange agreements ===z ext-info-rrrrrzStrict kex mode: z9In strict-kex mode, but KEXINIT was not the first packet!z3Incompatible ssh peer (no acceptable kex algorithm)zKex: {}z.Incompatible ssh peer (no acceptable host key)z;Incompatible ssh peer (can't match requested host key type)HostKeyz/Incompatible ssh server (no acceptable ciphers)r )rrz,Incompatible ssh server (no acceptable macs)MACz3Incompatible ssh server (no acceptable compression)z {!r} {!r} {!r} Compressionz=== End of kex handshake ===)+r&rrrjr_remote_ext_info_remote_strict_kex enumeraterrrrrrrrr_rr rGr rr^ _kex_inforrr;r?rr}rr3rrr8rrrKrrr get_so_farr)rrr%rrrrrrrrrrrprefixvalueto_popralgorexpected agreed_kexr agreed_keysagreed_local_ciphersagreed_remote_ciphersagreed_remote_macsagreed_local_macsagreed_remote_compressionagreed_local_compressionrps rkrTransport._parse_kex_init s,,Q// %&<=#)*D#E #)*D#E %&<=%&<=$*+F$G!$*+F$G!!"45!"45]+  %=> - ( / 07 8 7 8 / 0 / 0  9 :  9 : , - , -  MF}! IIe$E IIeX__V; <#  $ %*11+>? %:;!%"& /GAt{++(,% a#//#//S(/?@H$B)B)B) .t/H/H.IJ a#0 A   a   % %))1 #K    t))66 FJ}1143E3EFJ z?a #E ..A7= %))*Q-89   $(--2245BB''% ! )668LK +88$:M:MNK { q "@ )^   !4!4!6!>"M  I{1~{1~F   #'**77,$ %)**77,% !$(,99**$ %),99**% ! # $ )S1F-G1-L"A 13215  D--d6H6H     !%t**779MN" !%t**779MN! !%+88$:M:MN! "&+88$:M:MN"  ! "a 'S1C-D-I"> +1-,Q/       (,..;;-) % (,..;;-( $(,-::..( $ )--::..) % ( )Q .,-2GC $ $C" ,-.. ":!!<";A">  ((**  %78 ,alln<rmc URURnURSS5nUSnUSnURSU5nUR(a%UR SU5nUR SU5nO$UR SU5nUR S U5nUR URUUUR US 9nU(+=(a S UR;n URURS n URURS n UR(a"UR SU "5R5n O!UR SU "5R5n URRUUU(aSOU U(aSOU U(aSOU U UU(aUOSS9 URURSn U bWURS:wdUR(a6UR[ S5 URR#U "55 UR$(a1UR[ S5 URR'5 gg)zDswitch on newly negotiated encryption parameters for inbound trafficrFrrrACBDr rxrrr etm@openssh.comrrEFNr) block_engine block_size mac_enginemac_sizemac_keyetmr iv_inrr$Switching on inbound compression ...z8Resetting inbound seqno after NEWKEYS due to strict mode)rRrr%rrr_DECRYPTr _mac_info digest_sizerset_inbound_cipher_compression_inforrrrset_inbound_compressorrreset_seqno_in)rrr rLkey_sizeiv_sizerQkey_inenginerPrNrMrO compress_ins rk_activate_inboundTransport._activate_inbound s   !3!34xx 5),'  #((9j1   %%c73E&&sH5F%%c73E&&sH5F!!##mm " xA.$//A>>$//26:^^DOO4W=    ''Z\-E-EFG''Z\-E-EFG **!#tRX Dg%T + ,,T-D-DEaH  "  # #'9 9T=O=O IIeC D OO 2 2;= A  $ $ IIJ  OO * * , %rmc [5nUR[5 URU5 UR(a0UR [ S5 URR5 URURnURSS5nUSnUSnURSU5nUR(a%URSU5nURSU5nO$URS U5nURS U5nURURUUURUS 9n U(+=(a S UR ;n UR"UR S n UR"UR Sn UR(a"URSU "5R$5n O!URSU "5R$5n URR'S5nURR)U UU(aSOU U(aSOU U(aSOU UU UU(aUOSS9 UR*UR,SnUbWUR,S:wdUR.(a6UR [ S5 URR1U"55 URR35(dSUlUR(aUR6(aUR8S:XaSSR;UR<50n[5nUR[>5 URA[CU55 [EURG55H(unnURIU5 URIU5 M* URU5 URK[L5 g)zEswitch on newly negotiated encryption parameters for outbound trafficz9Resetting outbound seqno after NEWKEYS due to strict moderFrrrrErFrCrDrGrHrrrJrIz-ctrNr) rKrLrMrNrOsdctrrPr iv_outrr%Switching on outbound compression ...rzserver-sig-algs,)'rTrrr~rrrrreset_seqno_outrRrr%rrrrrrTrUendswithset_outbound_cipherrWrrset_outbound_compressorrrrr/rjrCrArrsorteditemsrrr )rrrr rLrZr[rckey_outr]rPrNrMrOrb compress_out extensionsr r5s rk_activate_outboundTransport._activate_outbound s I <  1  $ $ IIK  OO + + -  !2!23xx 5),'  #((9j1   &&sG4F''X6G&&sG4F''X6G!!""mm " x@.$..@>>$..1&9^^DNN3G<    ''Z\-E-EFG''Z\-E-EFG!!**62 ++!#tRX Dg!6t , --d.D.DEaH  #  " "&8 8DDNN$E$t & %+22:>?",rmcUR[S5 UR5 S=UlUlSUlSUlUR(aURc[U5UlUR(dS=Ul URl URbURR5 URR5(dSUlUR"R%5 UR&R5 UR"R)5 g!UR"R)5 f=f)NzSwitch to new keys ...TF)rrr_rrrrrrr rr_initial_kex_donerrrrrrrrrs rkr Transport._parse_newkeysR s  %12  599d2   !2!2!: +D 1D $$IM LD !DOO$E  ,  ! ! % % '))++DK '') .    " " $  # # + + -  # # + + -s D77EcUR5nUR5nUR[SR X#55 g)NzDisconnect (code {:d}): {})rrrrr)rrcodedescs rkrTransport._parse_disconnectn s2yy{zz| $4;;DGHrmcNUR5nUR[SRU55 UR 5nUR (d(UR[SRU55 SnOUS:XaFUR5nUR 5nURRXV5nU(aU4nO_US:Xa>UR5nUR 5nURRXV5 SnOURRX!5nSn[U5[LaUnSnU(a][5nU(a%UR[5 UR "U6 OUR["5 UR%U5 gg)NzReceived global request "{}"z*Rejecting "{}" global request from server.FrrT)rrrrr#rrrcheck_port_forward_requestcancel_port_forward_requestcheck_global_requestrrrTrr!rr"r~) rrr want_replyokrrextrarps rkr Transport._parse_global_requests sLzz| %7>>tDE]]_  II<CCDI B _ $jjlG99;D##>>wMBU + +jjlG99;D    : :7 IB##88AB 8u EB )C 12 12   s # rmcUR[S5 XlURbURR 5 gg)NzGlobal request successful.rrrrrrs rkr  Transport._parse_request_success s: %56   ,  ! ! % % ' -rmcUR[S5 SUlURbURR 5 gg)NzGlobal request denied.rrs rkr  Transport._parse_request_failure s< %12#  ,  ! ! % % ' -rmcvUR5nUR5nUR5nUR5nURRU5nUcUR[S5 gUR R 5 URX4U5 UR[SRU55 X R;a*URUR5 URU UR R5 g!UR R5 f=f)Nz%Success for unrequested channel! [??]zSecsh channel {:d} opened.) rrr%rrrr_set_remote_channelrrrrr)rrr server_chanidserver_window_sizeserver_max_packet_sizers rkr %Transport._parse_channel_open_success s YY[!"~~!!&) < IIgF G    $ $3I  IIe9@@H I,,,##F+//1''/ II    II   s A0DD8cUR5nUR5nUR5nUR5 [R"US5nUR [ SR X$U55 URR5 [X55Ul X R;aTURRU5 X R;a*URUR5 URU URR5 g!URR5 f=f)Nz(unknown code)z&Secsh channel {:d} open FAILED: {}: {})rrr#r%rrrrrr]rrrryrr)rrrr reason_str reason_texts rkr%Transport._parse_channel_open_failure sZZ\  ,009IJ   4 ; ;K   #3F#HD ,,,%%f-000''/335++F3 II    II   s A3D''EcT UR5nUR5nUR5nUR5nSnUS:XajURb]UR[S5 UR R 5 UR5nUR R5 GOUS:XaURbUR5nUR5n UR[SRX55 UR R 5 UR5nUR R5 GOUS:XaURbUR5n UR5n UR5nUR5n UR[SRX55 UR R 5 UR5nUR R5 GO6UR(d.UR[SRU55 S n[n OUR R 5 UR5nUR R5 US :Xa`UR5n UR5nUR5nUR5n URRUX4X45n OURR!X'5n U [":wa'UR[S RU55 S nU(au[%5nUR'[(5 UR+U5 UR+W 5 UR-S 5 UR-S 5 UR/U5 g[1W5nUR R 5 UR2R5UU5 S UR6U'UR9U5 UR;UR<UR>5 URAX4U5 UR R5 [%5nUR'[B5 UR+U5 UR+U5 UR+UR<5 UR+UR>5 UR/U5 UR[SRXr55 US:XaURU5 gUS:XaURUWW 45 gUS:Xa WW 4Ul"URUX4W W 45 gURGU5 g!UR R5 f=f!UR R5 f=f!UR R5 f=f!UR R5 f=f!UR R5 f=f)NFrz!Incoming forward agent connectionrz$Incoming x11 connection from {}:{:d}rz.Incoming tcp forwarded connection from {}:{:d}z+Rejecting "{}" channel request from server.Trz+Rejecting "{}" channel request from client.rrzSecsh channel {:d} ({}) opened.)$rrrrrrrrrrrrrr$r"check_channel_direct_tcpip_requestcheck_channel_requestr%rTrr&rrr~rrrrrrrrrr' origin_addrr)rrrrinitial_window_sizerreject my_chanidr origin_port server_addr server_portrr dest_portrprs rkrTransport._parse_channel_open szz|iik))+ , ,++7 IIe@ A II    $ ..0  !!#em$"3"3"?**,K))+K II6==  II    $ ..0  !!#''d.?.?.K**,K))+K**,K))+K II@GG  II    $ ..0  !!#!! II=DDTJ F ? & & +[9D    {0; 2L   ( ( .[ !!# !!#  !!# !!#Z II   s=V&V.%W +W,)A4X V+.W  W),X X'cUR5 UR5nUR5 UR[SR [ R "U555 g)Nz Debug msg: {})r#rurrrr safe_string)rrrps rkrTransport._parse_debugO sC lln  %//0@0@0EFGrmc$URR5 XR;aS/04URR5 $URUURR5 $!URR5 f=frgr rNs rk_get_subsystem_handler Transport._get_subsystem_handlerU so II   ///R| II   ''- II   DII   s-A3 A33B)Grrrrrrrr r\rrr/r0rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr)TTrg)NNN)NNNNN)NT) NrNNNFFTTrNrT)NNF)F)r __module__ __qualname____firstlineno____doc__objectrrSrrparamiko __version__r_preferred_ciphers_preferred_macsr_preferred_pubkeysrrG is_availablerr\rAESr CTRCBCrer AESGCMrRrrrrrTrXrErYrFrrJrKrHrIrLrMrRrSrQrNrOrPr2rCrDrWrrr;r<rr-propertyr3r8r?rCrGrKrVrZr^rdrprtryr} staticmethodrrYrrrrrrrrrrrrrrrrrkrrSrrrrrr-rGrrrOrRrUrYr^rarirrsrrzr~rrrrrrrrrrrrrrrrrrr&r)rr_rorrrr rr r r r rrrrr0r_request_successr1_request_failedr2_feedr3_feed_extendedr4_window_adjustr5_handle_requestr6 _handle_eofr7 _handle_closer__static_attributes__rrmrkroros xHxHI%%h&:&:;J  O O  N!!##:^K ' ^^II   ^^II   ^^II   ^^II   ^^II   ^^II  II  [[ # [[ # e9Lx $R0"&3#)26392)F#)26392)F!2.!$b1 I 6  '   ,V  ,V 6 ' x 3H x 3H!" x#$ 3H%& z'( +J)I0'0'1.40<)9)94@5B1:))) I!!##4A 01 ,-=>!12 M 0 7 k Z 11..    11--552 % !D8t@D7(*&&P "?C! F; ; I]~4l P /#$4:"#$J6 ~@ ( (   0 (=8Sj/=b3=jD.=4=. - - -4""*/"&+.4 . <&*2 ( J N $L jX  $)VFP& h=T8-tO)b B ,8I "$H( ( ,0|/|H   W55W44'--!7#9#9!7#9#9W44,,700 rmroc2\rSrSrSrSrSrSrSr\ S5r \ RS5r \ S 5r \ RS 5r \ S 5r \ RS 5r \ S 5r\RS5r\ S5r\RS5rSrg)r]im a Simple object containing the security preferences of an ssh transport. These are tuples of acceptable ciphers, digests, key types, and key exchange algorithms, listed in order of preference. Changing the contents and/or order of these fields affects the underlying `.Transport` (but only if you change them before starting the session). If you try to add an algorithm that paramiko doesn't recognize, ``ValueError`` will be raised. If you try to assign something besides a tuple to one of the fields, ``TypeError`` will be raised. _transportcXlgrgr)r transports rkrSecurityOptions.__init__| s#rmc8SRUR5$)rNz#)rrr2s rkrVSecurityOptions.__repr__ s5;;DOOLLrmcn[U5[La [U5n[U5[La [S5e[[ UR U5R 55nUVs/sH oUU;dM UPM nn[U5S:a [S5e[UR X5 gs snf)Nzexpected tuple or listrzunknown cipher) rrr TypeErrorr+rr;r ValueErrorr)rr origr'possiblen forbiddens rk_setSecurityOptions._set s 7d?aA 7% 45 56;;=> !71h%6Q 7 y>A -. .)8s , B29B2c.URR$)zSymmetric encryption ciphers)rrr2s rkr0SecurityOptions.ciphers s111rmc*URSSU5 g)NrrRrrr's rkr0r s &:rmc.URR$)z Digest (one-way hash) algorithms)rrr2s rkdigestsSecurityOptions.digests ...rmc*URSSU5 g)NrrTrrs rkrr  #[!4rmc.URR$)zPublic-key algorithms)rrr2s rk key_typesSecurityOptions.key_types rrmc*URSSU5 g)Nrrrrs rkrr rrmc.URR$)zKey exchange algorithms)rrr2s rkrFSecurityOptions.kex s---rmc*URSSU5 g)Nrr2rrs rkrFr s "K3rmc.URR$)zCompression algorithms)rr\r2s rkrJSecurityOptions.compression s555rmc*URSSU5 g)Nr\rWrrs rkrJr s *,?CrmrN)rrrrr __slots__rrVrrr0setterrrrFrJrrrmrkr]r]m s I$M *22 ^^;;// ^^55//55.. ZZ4466DDrmr]c8\rSrSrSrSrSrSrSrSr Sr g ) ri cl[R"5Ul[R"5Ulgrg)rWeakValueDictionary_maprr_lockr2s rkrChannelMap.__init__ s //1 ^^% rmcURR5 X RU'URR5 g!URR5 f=frg)rrrr)rrrs rkrChannelMap.put sD  ! $IIf  JJ   DJJ   s AA!cURR5 URRUS5URR 5 $!URR 5 f=frg)rrrr%rrvs rkr%ChannelMap.get sJ  !99==. JJ   DJJ   s AA.cURR5 URU URR 5 g![a N'f=f!URR 5 f=frg)rrrr|rrvs rkryChannelMap.delete sa  ! IIf% JJ      JJ   s# A AAAAA1cURR5 [URR 55URR 5 $!URR 5 f=frg)rrrrrrr2s rkrChannelMap.values sM  ! ((*+ JJ   DJJ   s "AA5cURR5 [UR5URR 5 $!URR 5 f=frg)rrrrrr2s rk__len__ChannelMap.__len__ sC  !tyy> JJ   DJJ   r )rrN) rrrrrrr%ryrrrrrmrkrr s & !!!!!rmrct^\rSrSrSrU4SjrSrSrSrSr SSjr S r SS jr SS jr S rS rSrU=r$)ServiceRequestingTransporti zX Transport, but also handling service requests, like it oughtta! .. versionadded:: 3.2 cn>[TU]"U0UD6 SUlURUR[ 'g)NF)superr_service_userauth_accepted_parse_service_acceptrr,)rrrrs rkr#ServiceRequestingTransport.__init__ s4 $)&)*/'262L2L./rmcUR5nUS:wa&UR[SRU55 gSUlUR[S5 g)N ssh-userauthz!Service request "{}" accepted (?)Tz+MSG_SERVICE_ACCEPT received; auth may begin)rrrrr)rrservices rkr0ServiceRequestingTransport._parse_service_accept sT**, n $ II:AA'J  +/' %FGrmcUR(aUR(d [S5eUR(ag[ 5nUR [ 5 URS5 UR[S5 URU5 UR(d)[R"S5 UR(dM)UR5Ulg)Nrrz)Sending MSG_SERVICE_REQUEST: ssh-userauthr)rrrarrTrr+rrrr~risleepget_auth_handlerrrs rkensure_session)ServiceRequestingTransport.ensure_session s T%:%: 45 5  * *  I '( ^$ %DE 111 JJsO111!113rmc[U5$rg)rr2s rkr +ServiceRequestingTransport.get_auth_handler4 s t$$rmcXUR5 URRU5$rg)r rrrrs rkr$ServiceRequestingTransport.auth_none8 s%   **844rmc ^UR5 URRUT5$![aJnU(aSUR;aeU4SjnUR X5sSnA$![ a Uef=fSnAff=f)Nr"c`>[U5S:a [S5e[U5S:Xa/$T/$r$r%r&s rkr9ServiceRequestingTransport.auth_password..handlerI r+rm)r rrr\r,r-ra)rrrr.r!rs ` rkr(ServiceRequestingTransport.auth_password= s  $$228XF F$  6aoo M  &,,X??  ' s,/ BA>A.(B. A;;A>>BcXUR5 URRX5$rg)r rr)rrrxs rkr)ServiceRequestingTransport.auth_publickeyY s%   //>>rmcZUR5 URRXU5$rg)r rr-rFs rkr-+ServiceRequestingTransport.auth_interactive^ s,   11 z  rmcZUR5 U(dSnURXU5$)Nc/nU(a[UR55 U(a[UR55 UH6upE[UR5SS9 UR[55 M8 U$r7r:r?s rkrAServiceRequestingTransport.auth_interactive_dumb..handlerm rErm)r r-rFs rkrG0ServiceRequestingTransport.auth_interactive_dumbe s-  $$X CCrmcUR5 UR5UlURRXU5$rg)r r rr)rrrrs rkr/ServiceRequestingTransport.auth_gssapi_with_micz s=  113  55   rmcUR5 UR5UlURRU5$rg)r r rrrs rkr,ServiceRequestingTransport.auth_gssapi_keyex s6  113  228<r?r@rArBparamiko.compressrCrDparamiko.dsskeyrEparamiko.ed25519keyrFparamiko.kex_curve25519rGparamiko.kex_gexrHrIparamiko.kex_group1rJparamiko.kex_group14rKrLparamiko.kex_group16rMparamiko.kex_ecdh_nistrNrOrPparamiko.kex_gssrQrRrSparamiko.messagerTparamiko.packetrUrVparamiko.primesrWparamiko.rsakeyrXparamiko.ecdsakeyrYparamiko.serverrZparamiko.sftp_clientr[paramiko.ssh_exceptionr\r]r^r_r`ra paramiko.utilrbrcrd/cryptography.hazmat.decrepit.ciphers.algorithmsre ImportError1cryptography.hazmat.primitives.ciphers.algorithmsrhrlatexitregisterrror]rrrrmrkrDsS(  --8>$$3333333333333h?"*11)=1HHCC$:'"&++LI  '(J/   "7J/`^NDNDb*!*!Z[=[=AcLKLsF)) F87F8