Name	Size	Mode	Actions
encoding.cpython-36.pyc	1794	0644	editdlrm
exc.cpython-36.pyc	3339	0644	editdlrm
jws.cpython-36.pyc	7452	0644	editdlrm
serializer.cpython-36.pyc	9515	0644	editdlrm
signer.cpython-36.pyc	8339	0644	editdlrm
timed.cpython-36.pyc	6192	0644	editdlrm
url_safe.cpython-36.pyc	2644	0644	editdlrm
_json.cpython-36.pyc	1490	0644	editdlrm
__init__.cpython-36.pyc	972	0644	editdlrm

3 _TBg�+�@s�dd
lZdd
l
ZddlmZ
ddlmZ
ddlmZ
ddlm Z
ddlm Z
ejee fZejeZejeejfZejeZeje ZejejeejeefefZejeejfZejejeefZejed�d d �ZGdd�d�Zd
S) �N�
)
� want_bytes)
� BadPayload)
�BadSignature)
�_make_keys_list)
�Signer)� serializer�returnc

Cst|j
i�
t�S)
z5Checks whether a serializer generates text or binary.)� isinstance�dumps�str)
r�r �?/tmp/pip-build-0s3hx122/itsdangerous/itsdangerous/serializer.py�is_text_serializersrc @sf
eZ
dZUd
ZeZejeZ e  gZed)e eejeeje eejed�dd�Zeed�
dd ��
Zd*eejejejd �dd�Zejed �dd�Zd+eed�dd�Zd,eejed�dd�Zd-ejeed�dd�Zd.ejejedd�dd�Zd/eeejejd�dd�Zd0ejeejd�dd �Zd1eee d!�d"d#�Z!d2eeeee d$�d%d&�Z"d3ejee d�d'd(�Z#dS)4� Serializera: A serializer wraps a :class:`~itsdangerous.signer.Signer` to enable serializing and securely signing data other than bytes. It can unsign to verify that the data hasn't been changed. The serializer provides :meth:`dumps` and :meth:`loads`, similar to :mod:`json`, and by default uses :mod:`json` internally to serialize the data to bytes. The secret key should be a random string of ``bytes`` and should not be saved to code or version control. Different salts should be used to distinguish signing in different contexts. See :doc:`/concepts` for information about the security of the secret key and salt. :param secret_key: The secret key to sign and verify with. Can be a list of keys, oldest to newest, to support key rotation. :param salt: Extra key to combine with ``secret_key`` to distinguish signatures in different contexts. :param serializer: An object that provides ``dumps`` and ``loads`` methods for serializing data to a string. Defaults to :attr:`default_serializer`, which defaults to :mod:`json`. :param serializer_kwargs: Keyword arguments to pass when calling ``serializer.dumps``. :param signer: A ``Signer`` class to instantiate when signing data. Defaults to :attr:`default_signer`, which defaults to :class:`~itsdangerous.signer.Signer`. :param signer_kwargs: Keyword arguments to pass when instantiating the ``Signer`` class. :param fallback_signers: List of signer parameters to try when unsigning with the default signer fails. Each item can be a dict of ``signer_kwargs``, a ``Signer`` class, or a tuple of ``(signer, signer_kwargs)``. Defaults to :attr:`default_fallback_signers`. .. versionchanged:: 2.0 Added support for key rotation by passing a list to ``secret_key``. .. versionchanged:: 2.0 Removed the default SHA-512 fallback signer from ``default_fallback_signers``. .. versionchanged:: 1.1 Added support for ``fallback_signers`` and configured a default SHA-512 fallback. This fallback is for users who used the yanked 1.0.0 release which defaulted to SHA-512. .. versionchanged:: 0.14 The ``signer`` and ``signer_kwargs`` parameters were added to the constructor. �itsdangerousN)� secret_key�saltr�serializer_kwargs�signer� signer_kwargs�fallback_signerscCs�t|
�
|_
|dk rt|�
}||_|dkr.|j}||_t|�
|_|dkrL|j}||_|pXi|_ |dkrrt |jpnf�
}||_|p~i|_ dS)
N)r�secret_keysrr�default_serializerrr�default_signerrr�list�default_fallback_signersrr)�selfrrrrrrrr r r�__init__Ys  






zSerializer.__init__)
r c

Cs |jdS)z�The newest (last) entry in the :attr:`secret_keys` list. This is for compatibility from before key rotation support was added. r�����)
r)
rr r rr�szSerializer.secret_key)�payloadrr cCsp|d
kr|j}|j
}nt
|�
}y|r4|j|
jd�
�
S|j|
�
Stk rj
}
ztd|d��
WYd
d
}~XnXd
S)a
Loads the encoded object. This function raises :class:`.BadPayload` if the payload is not valid. The ``serializer`` parameter can be used to override the serializer stored on the class. The encoded ``payload`` should always be bytes. Nzutf-8zSCould not load the payload because an exception occurred on unserializing the data.)
�original_error)rr�loads�decode� Exceptionr)rr rZis_text�
er r r�load_payload�s 






zSerializer.load_payload)�objr cCst|j
j|
f
|j�
�
S)
z�Dumps the encoded object. The return value is always bytes. If the internal serializer returns text, the value will be encoded as UTF-8. )rrrr)rr'r r r�dump_payload�szSerializer.dump_payload)rr cCs(|
d
kr|j}
|j
|jf
d|
i
|j��
S)z�Creates a new instance of the signer to be used. The default implementation uses the :class:`.Signer` base class. Nr)rrrr)rrr r r�make_signer�s
zSerializer.make_signerccs�|
d
kr|j}
|j
|
�
V
xd|jD]Z}t|t�r<|}|j}nt|t�rP|\}}n|j}x$|jD]}||f
d|
i
|��
V
q^Wq"Wd
S)z�Iterates over all signers to be tried for unsigning. Starts with the configured signer, then constructs each signer specified in ``fallback_signers``. Nr) rr)rr �dictr�tuplerr)rr�fallback�kwargsrr r r�iter_unsigners�s






zSerializer.iter_unsigners)r'rr cCs2t|j
|
�
�
}|j|�
j|�
}|jr.|jd
�
S|S)z�Returns a signed string serialized with the internal serializer. The return value can be either a byte or unicode string depending on the format of the internal serializer. zutf-8)rr(r)�signrr#)rr'rr �rvr r rr�s 

zSerializer.dumps)r'�
frr cCs|j|j
|
|��

d
S)z�Like :meth:`dumps` but dumps into a file. The file handle has to be compatible with what the internal serializer expects. N)�writer)rr'r1rr r r�dump�szSerializer.dump)�
srr-r cKsht|
�
}
d
}xJ|j
|�
D]<}y|j|j|
�
�
Stk rR
}
z |}WYd
d
}~XqXqWtjt|��
d
S)ziReverse of :meth:`dumps`. Raises :exc:`.BadSignature` if the signature validation fails. N)rr.r&Zunsignr�_t�cast)rr4rr-Zlast_exceptionr�errr r rr"�s




zSerializer.loads)r1rr cCs|j|
j
�|�S)
z)Like :meth:`loads` but loads from a file.)r"�read)rr1rr r r�load�szSerializer.load)r4rr cCs|j|
|�S)
a9Like :meth:`loads` but without verifying the signature. This is potentially very dangerous to use depending on how your serializer works. The return value is ``(signature_valid, payload)`` instead of just the payload. The first item will be a boolean that indicates if the signature is valid. This function never fails. Use it for debugging only and if you know that your serializer module is not exploitable (for example, do not use it with a pickle serializer). .. versionadded:: 0.15 )
�_loads_unsafe_impl)rr4rr r r�loads_unsafe�szSerializer.loads_unsafe)r4r�load_kwargs�load_payload_kwargsr cCs�|d
kri}yd|j|
f
d|i
|��
fSt
k r�
}
zJ|jd
krFdS|d
krRi}yd|j|jf
|�
fStk rz


dSXWYd
d
}~XnXd
S)zfLow level helper function to implement :meth:`loads_unsafe` in serializer subclasses. NTrF)FN)FN)r"rr r&r)rr4rr<r=r%r r rr:
s 







zSerializer._loads_unsafe_implcCs|j|
j
�|d
�S)zYLike :meth:`loads_unsafe` but loads from a file. .. versionadded:: 0.15 )
r)r;r8)rr1rr r r�load_unsafe"
szSerializer.load_unsafe)rNNNNN)
N)
N)
N)
N)
N)
N)
N)
N)NN)
N)$�__name__� __module__�__qualname__�__doc__�jsonrr5�Anyrr� _t_signerr�_t_fallbacks� _t_secret_key�_t_opt_str_bytes� _t_opt_kwargs�Optionalr�property�bytesrr&r(r)�Iteratorr.�_t_str_bytesrZIOr3r"r9�_t_load_unsafer;r:r>r r r rrs8 2 




*!

  



r) rCZtypingr5�encodingr�excrrrrr�UnionrrLrNrJrH�DictrDZ _t_kwargsrI�TyperEZListZTuplerF�boolrO�IterablerGrrr r r r�
s