CasperSecurity
o
h9Ra�G �
@ s� d Z ddlZddlZddlZddlmZmZmZmZm Z m
Z
m Z ddl m
Z
ddlZddlmZmZmZmZ e�e�Z d1deded ed
eegef d eegef d ef d
d�ZG dd� d�ZG dd� de�ZG dd� dej �Z G dd� dej ej e d�Z de!d efdd�Z"d2dede e# d ed e!fd d �Z$d e!d efd d!�Z%d2d ede e# d ed e!fd"d#�Z&d$ejj'd efd%d&�Z(d'ed ejj'fd(d)�Z)d*ejj'd efd+d,�Z*d'ed ejj'fd-d.�Z+G d/d0� d0e �Z,dS )3z�JSON (de)serialization framework.
The framework presented here is somewhat based on `Go's "json" package`_
(especially the ``omitempty`` functionality).
.. _`Go's "json" package`: http://golang.org/pkg/encoding/json/
� N)�Dict�Type�Any�Callable�List�Mapping�Optional)�crypto)�b64�errors�
interfaces�utilF� json_name�default� omitempty�decoder�encoder�returnc C s t | ||||d�S )a4 Convenient function to declare a :class:`Field` with proper type annotations.
This function allows to write the following code:
import josepy
class JSON(josepy.JSONObjectWithFields):
typ: str = josepy.field('type')
def other_type(self) -> str:
return self.typ
�r r r r r )� _TypedFieldr � r �2/usr/lib/python3/dist-packages/josepy/json_util.py�field s �r c
@ s e Zd ZdZdZ d#dedededeegef d eegef d
df d d �Z e
d
ed
efdd��Z d
ed
efdd�Z ded
d fdd�Z
deegef d
d fdd�Zdeegef d
d fdd�Zd
ed
efdd �Zd
ed
efd d �Ze
d
ed
efd d ��Ze
d
ed
efd!d"��ZdS )$�Fielda� JSON object field.
:class:`Field` is meant to be used together with
:class:`JSONObjectWithFields`.
``encoder`` (``decoder``) is a callable that accepts a single
parameter, i.e. a value to be encoded (decoded), and returns the
serialized (deserialized) value. In case of errors it should raise
:class:`~josepy.errors.SerializationError`
(:class:`~josepy.errors.DeserializationError`).
Note, that ``decoder`` should perform partial serialization only.
:ivar str json_name: Name of the field when encoded to JSON.
:ivar default: Default value (used when not present in JSON object).
:ivar bool omitempty: If ``True`` and the field value is empty, then
it will not be included in the serialized JSON object, and
``default`` will be used for deserialization. Otherwise, if ``False``,
field is considered as required, value will always be included in the
serialized JSON objected, and it must also be present when
deserializing.
)r r r �fdec�fencNFr r r r r r c C sD || _ || _|| _|d u r| jn|| _|d u r | j| _d S || _d S �N)r r r �default_decoderr �default_encoderr )�selfr r r r r r r r �__init__B s
zField.__init__�valuec C s t |t� o| S )z�Is the provided value considered "empty" for this field?
This is useful for subclasses that might want to override the
definition of being empty, e.g. for some more exotic data types.
)�
isinstance�bool��clsr! r r r �_emptyM s z Field._emptyc C s | � |�o| jS )zOmit the value in output?)r& r �r r! r r r �omitW s z
Field.omit�kwargsc K s0 | j | j| j| j| jd�|�}t| �di |��S )Nr r )r r r r r �type)r r) �currentr r r �_update_params[ s ��zField._update_paramsr c C � | j |d�S )z6Descriptor to change the decoder on JSON object field.)r �r, )r r r r r r f � z
Field.decoderr c C r- )z6Descriptor to change the encoder on JSON object field.)r r. )r r r r r r j r/ z
Field.encoderc C �
| � |�S )z4Decode a value, optionally with context JSON object.)r r' r r r �decoden �
z Field.decodec C r0 )z4Encode a value, optionally with context JSON object.)r r' r r r �encoder r2 z Field.encodec sJ t |t�rt� fdd�|D ��S t |t�r#t�� fdd�|�� D ��S |S )z�Default decoder.
Recursively deserialize into immutable types (
:class:`josepy.util.frozendict` instead of
:func:`dict`, :func:`tuple` instead of :func:`list`).
c 3 s � | ]}� � |�V qd S r �r )�.0�subvalue�r% r r � <genexpr>� s � z(Field.default_decoder.<locals>.<genexpr>c s" i | ]
\}}� � |�� � |��qS r r4 )r5 �keyr! r7 r r �
<dictcomp>� s �z)Field.default_decoder.<locals>.<dictcomp>)r" �list�tuple�dictr
�
frozendict�itemsr$ r r7 r r v s
��zField.default_decoderc C s |S )z Default (passthrough) encoder.r r$ r r r r � s zField.default_encoder�NFNN)�__name__�
__module__� __qualname__�__doc__� __slots__�strr r# r r � classmethodr& r( r, r r r1 r3 r r r r r r r ( s2 � � �
� r c @ s e Zd ZdZdS )r a Specialized class to mark a JSON object field with typed annotations.
This class is kept private because fields are supposed to be declared
using the :function:`field` in this situation.
In the future the :class:`Field` may be removed in favor of this one.N)rA rB rC rD r r r r r � s r c @ sL e Zd ZU dZi Zeeef ed< dede e deee
f dd fdd�Z d S )
�JSONObjectWithFieldsMetaa� Metaclass for :class:`JSONObjectWithFields` and its subclasses.
It makes sure that, for any class ``cls`` with ``__metaclass__``
set to ``JSONObjectWithFieldsMeta``:
1. All fields (attributes of type :class:`Field`) in the class
definition are moved to the ``cls._fields`` dictionary, where
keys are field attribute names and values are fields themselves.
2. ``cls.__slots__`` is extended by all field attribute names
(i.e. not :attr:`Field.json_name`). Original ``cls.__slots__``
are stored in ``cls._orig_slots``.
In a consequence, for a field attribute name ``some_field``,
``cls.some_field`` will be a slot descriptor and not an instance
of :class:`Field`. For example::
some_field = Field('someField', default=())
class Foo:
__metaclass__ = JSONObjectWithFieldsMeta
__slots__ = ('baz',)
some_field = some_field
assert Foo.__slots__ == ('some_field', 'baz')
assert Foo._orig_slots == ()
assert Foo.some_field is not Field
assert Foo._fields.keys() == ['some_field']
assert Foo._fields['some_field'] is some_field
As an implementation note, this metaclass inherits from
:class:`abc.ABCMeta` (and not the usual :class:`type`) to mitigate
the metaclass conflict (:class:`ImmutableMap` and
:class:`JSONDeSerializable`, parents of :class:`JSONObjectWithFields`,
use :class:`abc.ABCMeta` as its metaclass).
�_fields�name�bases� namespacer c C s� i }|D ] }|� t|di �� q|�� �� D ](\}}t|t�r>t|t�r7||�di �vr7td|� d|� d���|� |�||< q|�dd�|d< t
t |d �t |� � � �|d< ||d< t
j�| |||�S ) NrI �__annotations__zField `z` in JSONObject `z` has no type annotation.rE r � _orig_slots)�update�getattr�copyr? r" r r �get�
ValueError�popr< r; �keys�abc�ABCMeta�__new__)�mcsrJ rK rL �fields�baser9 r! r r r rX � s$
���z JSONObjectWithFieldsMeta.__new__N) rA rB rC rD rI r rF r rM r r rX r r r r rH � s
'
��rH c s� e Zd ZdZedeeef fdd��Zdeddf� fdd� Z d edefd
d �Z
deeef fd d
�Z deeef fdd�Z ede
eef ddfdd��Zede
eef defdd��Zedeeef dd fdd��Z� ZS )�JSONObjectWithFieldsa� JSON object with fields.
Example::
class Foo(JSONObjectWithFields):
bar = Field('Bar')
empty = Field('Empty', omitempty=True)
@bar.encoder
def bar(value):
return value + 'bar'
@bar.decoder
def bar(value):
if not value.endswith('bar'):
raise errors.DeserializationError('No bar suffix!')
return value[:-3]
assert Foo(bar='baz').to_partial_json() == {'Bar': 'bazbar'}
assert Foo.from_json({'Bar': 'bazbar'}) == Foo(bar='baz')
assert (Foo.from_json({'Bar': 'bazbar', 'Empty': '!'})
== Foo(bar='baz', empty='!'))
assert Foo(bar='baz').bar == 'baz'
r c C s dd� | j �� D �S )zGet default fields values.c S s i | ]\}}||j �qS r )r )r5 �slotr r r r r: � s �z2JSONObjectWithFields._defaults.<locals>.<dictcomp>)rI r? r7 r r r � _defaults� s �z JSONObjectWithFields._defaultsr) Nc s" t � jdi i | �� �|��� d S �Nr )�superr r^ )r r) �� __class__r r r s
�z JSONObjectWithFields.__init__rJ c C s> z| j | }W n ty t�d�|���w |�t| |��S )z�Encode a single field.
:param str name: Name of the field to be encoded.
:raises errors.SerializationError: if field cannot be serialized
:raises errors.Error: if field could not be found
zField not found: {0})rI �KeyErrorr �Error�formatr3 rP )r rJ r r r r r3 s �zJSONObjectWithFields.encodec C s� i }t � }| j�� D ]7\}}t| |�}|�|�r |�||f� q
z
|�|�||j< W q
tj yA } z
t� d�
|||���d}~ww |S )zSerialize fields to JSON.z Could not encode {0} ({1}): {2}N) �setrI r? rP r( �addr3 r r �SerializationErrorre )r �jobj�omittedr] r r! �errorr r r �fields_to_partial_json s"
����z+JSONObjectWithFields.fields_to_partial_jsonc C s | � � S r )rl )r r r r �to_partial_json) s z$JSONObjectWithFields.to_partial_jsonri c C sT t � }| j�� D ]\}}|js|j|vr|�|j� q|r(t�d�d� |����d S )Nz&The following fields are required: {0}�,)
rf rI r? r r rg r �DeserializationErrorre �join)r% ri �missing�_r r r r �_check_required, s ����z$JSONObjectWithFields._check_requiredc C s� | � |� i }| j�� D ]7\}}|j|vr |jr |j||< q ||j }z |�|�||< W q tjyC } z
t�d� |||���d}~ww |S )z Deserialize fields from JSON.z#Could not decode {0!r} ({1!r}): {2}N)
rs rI r? r r r r1 r ro re )r% ri rZ r] r r! rk r r r �fields_from_json8 s"
����z%JSONObjectWithFields.fields_from_jsonc C s | di | � |���S r_ )rt )r% ri r r r � from_jsonJ s z JSONObjectWithFields.from_json)rA rB rC rD rG r rF r r^ r r3 rl rm r rs rt ru �
__classcell__r r ra r r\ � s $r\ )� metaclass�datac C s t �| ��d�S )zJEncode JOSE Base-64 field.
:param bytes data:
:rtype: `str`
�ascii)r
� b64encoder1 )rx r r r �encode_b64joseO s r{ �size�minimumc
C st z t �| �� �}W n tjy } zt�|��d}~ww |dur8|s(t|�|ks0|r8t|�|k r8t�d�|���|S )a Decode JOSE Base-64 field.
:param unicode data:
:param int size: Required length (after decoding).
:param bool minimum: If ``True``, then `size` will be treated as
minimum required length, as opposed to exact equality.
:rtype: bytes
Nz&Expected at least or exactly {0} bytes) r
� b64decoder3 �binasciird r ro �lenre )rx r| r} �decodedrk r r r �decode_b64joseZ s
��� �r� r! c C s t �| ��� S )z;Hexlify.
:param bytes value:
:rtype: unicode
)r �hexlifyr1 )r! r r r � encode_hex16r s r� c
C sr | � � }|dur |st|�|d ks |r t|�|d k r t�� �zt�|�W S tjy8 } zt�|��d}~ww )a Decode hexlified field.
:param unicode value:
:param int size: Required length (after decoding).
:param bool minimum: If ``True``, then `size` will be treated as
minimum required length, as opposed to exact equality.
:rtype: bytes
N� )r3 r� r ro r � unhexlifyrd )r! r| r} �value_brk r r r � decode_hex16| s �
��r� �certc C �* t | jtj�r td��tt�tj| j��S )z�Encode certificate as JOSE Base-64 DER.
:type cert: `OpenSSL.crypto.X509` wrapped in `.ComparableX509`
:rtype: unicode
z.Error input is actually a certificate request.)r" �wrappedr �X509ReqrS r{ �dump_certificate�
FILETYPE_ASN1)r� r r r � encode_cert� �
�r� �b64derc
C �@ z
t �t�tjt| ���W S tjy } zt�|��d}~ww )z�Decode JOSE Base-64 DER-encoded certificate.
:param unicode b64der:
:rtype: `OpenSSL.crypto.X509` wrapped in `.ComparableX509`
N) r
�ComparableX509r �load_certificater� r� rd r ro �r� rk r r r � decode_cert� �
�
��r� �csrc C r� )zEncode CSR as JOSE Base-64 DER.
:type csr: `OpenSSL.crypto.X509Req` wrapped in `.ComparableX509`
:rtype: unicode
z&Error input is actually a certificate.)r" r� r �X509rS r{ �dump_certificate_requestr� )r� r r r �
encode_csr� r� r� c
C r� )z�Decode JOSE Base-64 DER-encoded CSR.
:param unicode b64der:
:rtype: `OpenSSL.crypto.X509Req` wrapped in `.ComparableX509`
N) r
r� r �load_certificate_requestr� r� rd r ro r� r r r �
decode_csr� r� r� c @ s� e Zd ZU dZeZeed< dZeed< eZ e
ee f ed< e dde d de
e de d fd d
��Ze d eeef de d fd d
��Zde
eef fdd�Ze d eeef dd fdd��ZdS )�TypedJSONObjectWithFieldszJSON object with type.�typr* �type_field_name�TYPESN�type_clsr c C s |du r|j n|}|| j|< |S )z(Register class for JSON deserialization.N)r� r� )r% r� r� r r r �register� s
z"TypedJSONObjectWithFields.registerri c C s� | | j �� v r| j|vrt�d�| j���| S t|t�s$t�d�|���z|| j }W n ty7 t�d��w z| j | W S tyK t� ||��w )z&Get the registered class for ``jobj``.zMissing type field ({0})z {0} is not a dictionary objectzmissing type field)
r� �valuesr� r ro re r" r= rc �UnrecognizedTypeError)r% ri r� r r r � get_type_cls� s(
�
�
� �z&TypedJSONObjectWithFields.get_type_clsc C s | � � }| j|| j< |S )a Get JSON serializable object.
:returns: Serializable JSON object representing ACME typed object.
:meth:`validate` will almost certainly not work, due to reasons
explained in :class:`josepy.interfaces.IJSONSerializable`.
:rtype: dict
)rl r� r� )r ri r r r rm � s z)TypedJSONObjectWithFields.to_partial_jsonc C s | � |�}|di |�|���S )z�Deserialize ACME object from valid JSON object.
:raises josepy.errors.UnrecognizedTypeError: if type
of the ACME object has not been registered.
Nr )r� rt )r% ri r� r r r ru s
z#TypedJSONObjectWithFields.from_jsonr )rA rB rC rD �NotImplementedr� rF rM r� r� r r rG r r� r r r� rm ru r r r r r� � s(
�� �
r� r@ )NF)-rD rV r �logging�typingr r r r r r r �OpenSSLr � josepy.util�josepyr
r r r
� getLoggerrA �loggerrF r# r r r rW rH � ImmutableMap�JSONDeSerializabler\ �bytesr{ �intr� r� r� r� r� r� r� r� r� r r r r �<module> sD $
� � �
�i D�q