403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.85
Web Server : Apache
System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64
User : sws1074145052 ( 1074145052)
PHP Version : 8.3.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/openid/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3/dist-packages/openid/__pycache__/association.cpython-311.pyc
�

|=�^~G��>�dZddlZddlZddlmZddlmZddlmZddlmZgd�Z	dd	gZ
eed
��ree
��Z
gd�Zdd
gZn
dgZ
ddgZdgZd�Zd�ZGd�de��Zee��Zee��Zd�ZejGd�de����ZdS)a�
This module contains code for dealing with associations between
consumers and servers. Associations contain a shared secret that is
used to sign C{openid.mode=id_res} messages.

Users of the library should not usually need to interact directly with
associations. The L{store<openid.store>}, L{server<openid.server.server>}
and L{consumer<openid.consumer.consumer>} objects will create and manage
the associations. The consumer and server code will make use of a
C{L{SessionNegotiator}} when managing associations, which enables
users to express a preference for what kind of associations should be
allowed, and what kind of exchange should be done to establish the
association.

@var default_negotiator: A C{L{SessionNegotiator}} that allows all
    association types that are specified by the OpenID
    specification. It prefers to use HMAC-SHA1/DH-SHA1, if it's
    available. If HMAC-SHA256 is not supported by your Python runtime,
    HMAC-SHA256 and DH-SHA256 will not be available.

@var encrypted_negotiator: A C{L{SessionNegotiator}} that
    does not support C{'no-encryption'} associations. It prefers
    HMAC-SHA1/DH-SHA1 association types if available.
�N)�	cryptutil)�kvform)�oidutil)�	OPENID_NS)�default_negotiator�encrypted_negotiator�SessionNegotiator�Association�	HMAC-SHA1�HMAC-SHA256�
hmacSha256)�r�DH-SHA1�r�
no-encryption�r�	DH-SHA256)rrrrrc�@�ddgddgd�}|�|g��S)z=Return the allowed session types for a given association typerrr�rr)�get)�
assoc_type�assoc_to_sessions  �4/usr/lib/python3/dist-packages/openid/association.py�getSessionTypesrJs9�� ��1�#�_�5�������
�B�/�/�/�c�R�|t|��vrtd|�d|�����dS)zPCheck to make sure that this pair of assoc type and session
    type are allowedz
Session type z not valid for assocation type N)r�
ValueError)r�session_types  r�checkSessionTyperSsC���?�:�6�6�6�6��j�&�,�,�
�
�4�5�5�	5�7�6rc�8�eZdZdZd�Zd�Zd�Zd	d�Zd�Zd�Z	dS)
r	a�A session negotiator controls the allowed and preferred
    association types and association session types. Both the
    C{L{Consumer<openid.consumer.consumer.Consumer>}} and
    C{L{Server<openid.server.server.Server>}} use negotiators when
    creating associations.

    You can create and use negotiators if you:

     - Do not want to do Diffie-Hellman key exchange because you use
       transport-layer encryption (e.g. SSL)

     - Want to use only SHA-256 associations

     - Do not want to support plain-text associations over a non-secure
       channel

    It is up to you to set a policy for what kinds of associations to
    accept. By default, the library will make any kind of association
    that is allowed in the OpenID 2.0 specification.

    Use of negotiators in the library
    =================================

    When a consumer makes an association request, it calls
    C{L{getAllowedType}} to get the preferred association type and
    association session type.

    The server gets a request for a particular association/session
    type and calls C{L{isAllowed}} to determine if it should
    create an association. If it is supported, negotiation is
    complete. If it is not, the server calls C{L{getAllowedType}} to
    get an allowed association type to return to the consumer.

    If the consumer gets an error response indicating that the
    requested association/session type is not supported by the server
    that contains an assocation/session type to try, it calls
    C{L{isAllowed}} to determine if it should try again with the
    given combination of association/session type.

    @ivar allowed_types: A list of association/session types that are
        allowed by the server. The order of the pairs in this list
        determines preference. If an association/session type comes
        earlier in the list, the library is more likely to use that
        type.
    @type allowed_types: [(str, str)]
    c�0�|�|��dS�N)�setAllowedTypes)�self�
allowed_typess  r�__init__zSessionNegotiator.__init__�s�����]�+�+�+�+�+rc�P�|�t|j����Sr")�	__class__�listr%�r$s r�copyzSessionNegotiator.copy�s���~�~�d�4�#5�6�6�7�7�7rc�D�|D]\}}t||���||_dS)z[Set the allowed association types, checking to make sure
        each combination is valid.N)rr%)r$r%rrs    rr#z!SessionNegotiator.setAllowedTypes�s9��+8�	7�	7�&�Z���Z��6�6�6�6�*����rNc��|j�g|_|�Mt|��}|std|�����t|��D]}|�||���dSt	||��|j�||f��dS)z�Add an association type and session type to the allowed
        types list. The assocation/session pairs are tried in the
        order that they are added.Nz*No session available for association type )r%rr�addAllowedTyper�append)r$rr�	availables    rr.z SessionNegotiator.addAllowedType�s�����%�!#�D����'�
�3�3�I��
3� �j�$.�J�"2�3�3�3�!0�
� ;� ;�
>�
>���#�#�J��=�=�=�=�
>�
>�
�Z��6�6�6���%�%�z�<�&@�A�A�A�A�Arc�B�||f|jv}|t|��v}|o|S)zAIs this combination of association type and session type allowed?)r%r)r$rr�
assoc_good�matchess     r�	isAllowedzSessionNegotiator.isAllowed�s1�� �,�/�4�3E�E�
��/�*�"=�"=�=���%�g�%rc�@�	|jdS#t$rYdSwxYw)zIGet a pair of assocation type and session type that are
        supportedr)NN)r%�
IndexErrorr*s r�getAllowedTypez SessionNegotiator.getAllowedType�s7��	 ��%�a�(�(���	 �	 �	 ��<�<�	 ���s��
�r")
�__name__�
__module__�__qualname__�__doc__r&r+r#r.r4r7�rrr	r	[s�������-�-�^,�,�,�8�8�8�+�+�+�B�B�B�B�(&�&�&� � � � � rr	c�F�|dkrdS|dkrdStd|�����)Nr�r� zUnsupported association type: )r)rs r�
getSecretSizer@�s7���[� � ��r�	�}�	$�	$��r��j�z�z�L�M�M�Mrc��eZdZdZgd�Zejejd�Ze	d���Z
d�Zedd���Z
d�Zd	�Zd
�Zd�Ze	d���Zd
�Zd�Zd�Zd�Zd�Zd�ZdS)r
an
    This class represents an association between a server and a
    consumer.  In general, users of this library will never see
    instances of this object.  The only exception is if you implement
    a custom C{L{OpenIDStore<openid.store.interface.OpenIDStore>}}.

    If you do implement such a store, it will need to store the values
    of the C{L{handle}}, C{L{secret}}, C{L{issued}}, C{L{lifetime}}, and
    C{L{assoc_type}} instance variables.

    @ivar handle: This is the handle the server gave this association.

    @type handle: C{str}


    @ivar secret: This is the shared secret the server generated for
        this association.

    @type secret: C{str}


    @ivar issued: This is the time this association was issued, in
        seconds since 00:00 GMT, January 1, 1970.  (ie, a unix
        timestamp)

    @type issued: C{int}


    @ivar lifetime: This is the amount of time this association is
        good for, measured in seconds since the association was
        issued.

    @type lifetime: C{int}


    @ivar assoc_type: This is the type of association this instance
        represents.  The only valid value of this field at this time
        is C{'HMAC-SHA1'}, but new types may be defined in the future.

    @type assoc_type: C{str}


    @sort: __init__, fromExpiresIn, expiresIn, __eq__, __ne__,
        handle, secret, issued, lifetime, assoc_type
    ��version�handle�secret�issued�lifetimerrc�d�ttj����}|}||||||��S)a�
        This is an alternate constructor used by the OpenID consumer
        library to create associations.  C{L{OpenIDStore
        <openid.store.interface.OpenIDStore>}} implementations
        shouldn't use this constructor.


        @param expires_in: This is the amount of time this association
            is good for, measured in seconds since the association was
            issued.

        @type expires_in: C{int}


        @param handle: This is the handle the server gave this
            association.

        @type handle: C{str}


        @param secret: This is the shared secret the server generated
            for this association.

        @type secret: C{str}


        @param assoc_type: This is the type of association this
            instance represents.  The only valid value of this field
            at this time is C{'HMAC-SHA1'}, but new types may be
            defined in the future.

        @type assoc_type: C{str}
        )�int�time)�cls�
expires_inrDrErrFrGs       r�
fromExpiresInzAssociation.fromExpiresIns5��F�T�Y�[�[�!�!�����s�6�6�6�8�Z�@�@�@rc���|tvrd}t||fz���||_t|t��r|�d��}||_||_||_||_	dS)a�
        This is the standard constructor for creating an association.


        @param handle: This is the handle the server gave this
            association.

        @type handle: C{str}


        @param secret: This is the shared secret the server generated
            for this association.

        @type secret: C{str}


        @param issued: This is the time this association was issued,
            in seconds since 00:00 GMT, January 1, 1970.  (ie, a unix
            timestamp)

        @type issued: C{int}


        @param lifetime: This is the amount of time this association
            is good for, measured in seconds since the association was
            issued.

        @type lifetime: C{int}


        @param assoc_type: This is the type of association this
            instance represents.  The only valid value of this field
            at this time is C{'HMAC-SHA1'}, but new types may be
            defined in the future.

        @type assoc_type: C{str}
        z&%r is not a supported association type�utf-8N)
�all_association_typesrrD�
isinstance�str�encoderErFrGr)r$rDrErFrGr�fmts       rr&zAssociation.__init__/sw��L�2�2�2�:�C��S�J�>�1�2�2�2�����f�c�"�"�	,��]�]�7�+�+�F������� ��
�$����rNc��|� ttj����}td|j|jz|z
��S)a1
        This returns the number of seconds this association is still
        valid for, or C{0} if the association is no longer valid.


        @return: The number of seconds this association is still valid
            for, or C{0} if the association is no longer valid.

        @rtype: C{int}
        Nr)rIrJ�maxrFrG)r$�nows  r�	expiresInzAssociation.expiresInhs:���;��d�i�k�k�"�"�C��1�d�k�D�M�1�C�7�8�8�8rc�"�|j|jkS)z�
        Compare two C{L{Association}} instances to determine relative
        ordering.

        Currently compares object lifetimes -- C{L{Association}} A < B
        if A.lifetime < B.lifetime.
        )rG�r$�others  r�__lt__zAssociation.__lt__ys���}�u�~�-�-rc�^�t|��t|��uo|j|jkS)z�
        This checks to see if two C{L{Association}} instances
        represent the same association.


        @return: C{True} if the two instances represent the same
            association, C{False} otherwise.

        @rtype: C{bool}
        )�type�__dict__rZs  r�__eq__zAssociation.__eq__�s)���D�z�z�T�%�[�[�(�L�T�]�e�n�-L�Lrc��||kS)z�
        This checks to see if two C{L{Association}} instances
        represent different associations.


        @return: C{True} if the two instances represent different
            associations, C{False} otherwise.

        @rtype: C{bool}
        r<rZs  r�__ne__zAssociation.__ne__�s���E�M�"�"rc	��d|jtj|j��t	t|j����t	t|j����|jd�}t|��t|j
��ksJ�g}|j
D]}|�|||f��� tj
|d���S)z�
        Convert an association to KV form.

        @return: String in KV form suitable for deserialization by
            deserialize.

        @rtype: str
        �2rBT��strict)rDr�toBase64rErRrIrFrGr�len�
assoc_keysr/r�seqToKV)r$�data�pairs�
field_names    r�	serializezAssociation.serialize�s�����k��&�t�{�3�3��#�d�k�*�*�+�+��C��
�.�.�/�/��/�

�
���4�y�y�C���0�0�0�0�0�0����/�	9�	9�J��L�L�*�d�:�&6�7�8�8�8�8��~�e�D�1�1�1�1rc��tj|d���}g}g}|D]/\}}|�|��|�|���0||jkrt	d|���|\}}}	}
}}|dkrt	d|z���t|
��}
t|��}t
j|	��}	|||	|
||��S)z�
        Parse an association as stored by serialize().

        inverse of serialize

        @param assoc_s: Association as serialized by serialize()
        @type assoc_s: bytes

        @return: instance of this class
        TrezUnexpected key values: %rrdzUnknown version: %r)r�kvToSeqr/rirrIr�
fromBase64)
rK�assoc_srl�keys�values�k�vrCrDrErFrGrs
             r�deserializezAssociation.deserialize�s�����w�t�4�4�4�������	�	�D�A�q��K�K��N�N�N��M�M�!������3�>�!�!��8�$�?�?�?�@F�=������:��c�>�>��2�W�<�=�=�=��V�����x�=�=���#�F�+�+���s�6�6�6�8�Z�@�@�@rc��tj|��}	|j|j}n%#t$rtd|j�����wxYw||j|��S)a
        Generate a signature for a sequence of (key, value) pairs


        @param pairs: The pairs to sign, in order
        @type pairs: sequence of (str, str)


        @return: The binary signature of this sequence of pairs
        @rtype: bytes
        zUnknown association type: )rrj�_macsr�KeyErrorrrE)r$rl�kv�macs    r�signzAssociation.sign�sy���^�E�
"�
"��	2��*�T�_�-�C�C���	2�	2�	2��*�"�o�o�1�2�2�
2�	2�����s�4�;��#�#�#s	�)�"Ac�z�|�|��}tj|�|����S)a=Return the signature of a message.

        If I am not a sign-all association, the message must have a
        signed list.

        @return: the signature, base64 encoded

        @rtype: bytes

        @raises ValueError: If there is no signed list and I am not a sign-all
            type of association.
        )�
_makePairsrrgr})r$�messagerls   r�getMessageSignaturezAssociation.getMessageSignature�s2������(�(�����	�	�%� 0� 0�1�1�1rc��|�td��s|�td��rtd���|�td��}|r||jkrtd���|���}|�td|j��t|����	����}d�|D��}|�
d��|���|�tdd�|����|�
|��}|�td|��|S)z�Add a signature (and a signed list) to a message.

        @return: a new Message object with a signature
        @rtype: L{openid.message.Message}
        �sig�signedz,Message already has signed list or signature�assoc_handlez*Message has a different association handlec�L�g|]!}|�d���|dd���"S)�openid.�N)�
startswith)�.0rus  r�
<listcomp>z+Association.signMessage.<locals>.<listcomp>s1��N�N�N��a�l�l�9�6M�6M�N�q����u�N�N�Nr�,)�hasKeyrr�getArgrDr+�setArgr)�
toPostArgsrsr/�sort�joinr�)r$r��
extant_handle�signed_message�message_keys�signed_listr�s       r�signMessagezAssociation.signMessage�sR��
�N�N�9�e�,�,�	M����y�(�3�3�	M��K�L�L�L����y�.�A�A�
��	K�]�d�k�9�9��I�J�J�J� ���������i����E�E�E��N�5�5�7�7�<�<�>�>�?�?��N�N�l�N�N�N�����8�$�$�$����������i��3�8�8�K�3H�3H�I�I�I��&�&�~�6�6�����i���4�4�4��rc���|�td��}|st|�d����|�|��}|�d��}tj||��S)z�Given a message with a signature, calculate a new signature
        and return whether it matches the signature in the message.

        @raises ValueError: if the message has no signature or no signature
            can be calculated for it.
        r�z has no sig.rO)r�rrr��decoder�const_eq)r$r��message_sig�calculated_sigs    r�checkMessageSignaturez!Association.checkMessageSignaturesm���n�n�Y��6�6���	=�����;�<�<�<��1�1�'�:�:��'�.�.�w�7�7���!�.�+�>�>�>rc� �|�td��}|std|�����|�d��}g}|���}|D]0}|�||�d|zd��f���1|S)Nr�zMessage has no signed list: r�r��)r�rr�splitr�r/r)r$r�r�r�rlrk�fields       rrzAssociation._makePairs#s������	�8�4�4���	M��*���K�L�L�L��l�l�3�'�'�����!�!�#�#�� �	C�	C�E��L�L�%����)�e�*;�R�!@�!@�A�B�B�B�B��rc	�\�d|jj�d|jj�d|j�d|j�d�	S)N�<�.� �>)r(r9r8rrDr*s r�__repr__zAssociation.__repr__/s;���"&�.�";�";�";�"&�.�"9�"9�"9�4�?�?�?�"&�+�+�+�/�	/rr")r8r9r:r;rir�hmacSha1r
ry�classmethodrMr&�propertyrXr\r`rbrnrwr}r�r�r�rr�r<rrr
r
�sP������,�,�^���J��'� �+�
�
�E�
�$A�$A��[�$A�L7%�7%�7%�r�9�9�9��X�9� .�.�.�M�M�M�#�#�#�2�2�2�4�A�A��[�A�:$�$�$�,2�2�2� ���2
?�
?�
?�
�
�
�/�/�/�/�/rr
)r;rJ�	functools�openidrrr�openid.messager�__all__rP�hasattrr)�supported_association_types�default_association_order� only_encrypted_association_orderrr�objectr	rrr@�total_orderingr
r<rr�<module>r�s�����0��������������������������$�$�$�$�$�$���������
�7�9�l�#�#��"&�$�'<�"=�"=��!�!�!��	!�$�(�$�$�
$/�-��	!�&�!��	!�(�$�
0�0�0�5�5�5�^ �^ �^ �^ �^ ��^ �^ �^ �B'�&�'@�A�A��(�(�)I�J�J��N�N�N���h/�h/�h/�h/�h/�&�h/�h/���h/�h/�h/r

Youez - 2016 - github.com/yon3zu
LinuXploit