o Df t@sddlmZddlmZddlmZmZmZmZddl m Z m Z m Z ddl mZmZmZddlmZmZmZmZmZmZmZmZmZGdddZd d Zd S) ) OrderedDict)deepcopy)to_bytesurlsafe_b64encodejson_b64encode to_unicode)$JWEAlgorithmWithTagAwareKeyAgreementJWESharedHeader JWEHeader)extract_headerextract_segment ensure_dict) DecodeErrorMissingAlgorithmErrorUnsupportedAlgorithmErrorMissingEncryptionAlgorithmError#UnsupportedEncryptionAlgorithmError$UnsupportedCompressionAlgorithmErrorInvalidHeaderParameterNameError)InvalidAlgorithmForMultipleRecipientsModeKeyMismatchErrorc@seZdZegdZiZiZiZdddZe ddZ d ddZ d d d Z d d d Z dd dZdddZdddZeddZddZddZddZddZddZdS)!JsonWebEncryption) algenczipjkujwkkidx5ux5cx5tzx5t#S256typctycritNcCs||_||_dSN) _algorithms_private_headers)self algorithmsprivate_headersr*Q/home/ubuntu/webapp/venv/lib/python3.10/site-packages/authlib/jose/rfc7516/jwe.py__init__$s zJsonWebEncryption.__init__cCsn|r|jdkrtd||jdkr||j|j<dS|jdkr(||j|j<dS|jdkr5||j|j<dSdS)z?Register an algorithm for ``alg`` or ``enc`` or ``zip`` of JWE.JWEzInvalid algorithm for JWE, rrrN)algorithm_type ValueErroralgorithm_location ALG_REGISTRYname ENC_REGISTRY ZIP_REGISTRY)cls algorithmr*r*r+register_algorithm(s   z$JsonWebEncryption.register_algorithmc Cs||}||}||}||||||t|||}|dur*||}t|trK|jdurK| |||}|d} |d} | |dn(t|trY| ||||} n| |||} | d} | d} d| vrs| | d| } t |}t|d}|r|t|}nt|}|||| | \}}t|tr|jdur|||||| | |} | d} d|t| t| t|t|gS)aGenerate a JWE Compact Serialization. The JWE Compact Serialization represents encrypted content as a compact, URL-safe string. This string is:: BASE64URL(UTF8(JWE Protected Header)) || '.' || BASE64URL(JWE Encrypted Key) || '.' || BASE64URL(JWE Initialization Vector) || '.' || BASE64URL(JWE Ciphertext) || '.' || BASE64URL(JWE Authentication Tag) Only one recipient is supported by the JWE Compact Serialization and it provides no syntax to represent JWE Shared Unprotected Header, JWE Per-Recipient Unprotected Header, or JWE AAD values. :param protected: A dict of protected header :param payload: Payload (bytes or a value convertible to bytes) :param key: Public key used to encrypt payload :param sender_key: Sender's private key in case JWEAlgorithmWithTagAwareKeyAgreement is used :return: JWE compact serialization as bytes Nepkcekheaderekascii.)get_header_algget_header_encget_header_zip_validate_sender_key_validate_private_headers prepare_key isinstancerkey_size!generate_keys_and_prepare_headersupdatewrap generate_ivrrcompressencryptagree_upon_key_and_wrap_cekjoinr)r' protectedpayloadkey sender_keyrrzip_algprepr8r9wrappedr;ivprotected_segmentaadmsg ciphertexttagr*r*r+serialize_compact6sJ         z#JsonWebEncryption.serialize_compactc CsXt|ts|g}|stdt|}t|}|d}|dur'dd|D}tt|D]}||dur9i||<d||vrEi||d<q-|d}t|t|kr_td t|t|| |} | |} | |} | || ||| |D] } || d| q|tt|D]}t| ||d||||<q|dur| |}| | |d } d | vr| d }nd}t|d kr|durt| jd| vr|| dt| tr| jdurg}tt|D]&}| | |||| }|dur|d }||d ||d|dqnGtt|D]@}t| tr*| | ||||| }n | | |||| }|dur=|d }|d ||d<d|vrU||d|dq| }|jrdt|jnd}|durs|dt|7}t|d}| r| t|}nt|}| ||||\}}t| tr| jdurtt|D]}| !| ||||||||}|d ||d<qt"}|jrt#t|j|d<|j$r|j$|d<|D]'} | ds| d=t#t| d| d<t%| &D] }|dvr| |=qq||d<|durt#t||d<t#t||d<t#t||d<t#t||d<|S)a[Generate a JWE JSON Serialization (in fully general syntax). The JWE JSON Serialization represents encrypted content as a JSON object. This representation is neither optimized for compactness nor URL safe. The following members are defined for use in top-level JSON objects used for the fully general JWE JSON Serialization syntax: protected The "protected" member MUST be present and contain the value BASE64URL(UTF8(JWE Protected Header)) when the JWE Protected Header value is non-empty; otherwise, it MUST be absent. These Header Parameter values are integrity protected. unprotected The "unprotected" member MUST be present and contain the value JWE Shared Unprotected Header when the JWE Shared Unprotected Header value is non-empty; otherwise, it MUST be absent. This value is represented as an unencoded JSON object, rather than as a string. These Header Parameter values are not integrity protected. iv The "iv" member MUST be present and contain the value BASE64URL(JWE Initialization Vector) when the JWE Initialization Vector value is non-empty; otherwise, it MUST be absent. aad The "aad" member MUST be present and contain the value BASE64URL(JWE AAD)) when the JWE AAD value is non-empty; otherwise, it MUST be absent. A JWE AAD value can be included to supply a base64url-encoded value to be integrity protected but not encrypted. ciphertext The "ciphertext" member MUST be present and contain the value BASE64URL(JWE Ciphertext). tag The "tag" member MUST be present and contain the value BASE64URL(JWE Authentication Tag) when the JWE Authentication Tag value is non-empty; otherwise, it MUST be absent. recipients The "recipients" member value MUST be an array of JSON objects. Each object contains information specific to a single recipient. This member MUST be present with exactly one array element per recipient, even if some or all of the array element values are the empty JSON object "{}" (which can happen when all Header Parameter values are shared between all recipients and when no encrypted key is used, such as when doing Direct Encryption). The following members are defined for use in the JSON objects that are elements of the "recipients" array: header The "header" member MUST be present and contain the value JWE Per- Recipient Unprotected Header when the JWE Per-Recipient Unprotected Header value is non-empty; otherwise, it MUST be absent. This value is represented as an unencoded JSON object, rather than as a string. These Header Parameter values are not integrity protected. encrypted_key The "encrypted_key" member MUST be present and contain the value BASE64URL(JWE Encrypted Key) when the JWE Encrypted Key value is non-empty; otherwise, it MUST be absent. This implementation assumes that "alg" and "enc" header fields are contained in the protected or shared unprotected header. :param header_obj: A dict of headers (in addition optionally contains JWE AAD) :param payload: Payload (bytes or a value convertible to bytes) :param keys: Public keys (or a single public key) used to encrypt payload :param sender_key: Sender's private key in case JWEAlgorithmWithTagAwareKeyAgreement is used :return: JWE JSON serialization (in fully general syntax) as dict Example of `header_obj`:: { "protected": { "alg": "ECDH-1PU+A128KW", "enc": "A256CBC-HS512", "apu": "QWxpY2U", "apv": "Qm9iIGFuZCBDaGFybGll" }, "unprotected": { "jku": "https://alice.example.com/keys.jwks" }, "recipients": [ { "header": { "kid": "bob-key-2" } }, { "header": { "kid": "2021-05-06" } } ], "aad": b'Authenticate me too.' } zNo keys have been provided recipientsNcSsg|]}iqSr*r*).0_r*r*r+ sz4JsonWebEncryption.serialize_json..r:rWzCCount of recipient keys {} does not equal to count of recipients {}rr9r8r; encrypted_keyr=r<rN unprotected>r:rarUrYrZ)'rDlistr/rr from_dictgetrangelenformatr>r?r@rArBrCgenerate_presetrr2update_protectedrrErFappendrGrHrIrNrrrrJrKrLrrrcsetkeys)r' header_objrOrnrQ shared_headerr\ijwe_aadrrrR recipientpresetr9epksrSrTrUrWrXrYrZobjmemberr*r*r+serialize_jsons j                       z JsonWebEncryption.serialize_jsoncCs8d|vs d|vs d|vr|||||S|||||S)aGenerate a JWE Serialization. It will automatically generate a compact or JSON serialization depending on `header` argument. If `header` is a dict with "protected", "unprotected" and/or "recipients" keys, it will call `serialize_json`, otherwise it will call `serialize_compact`. :param header: A dict of header(s) :param payload: Payload (bytes or a value convertible to bytes) :param key: Public key(s) used to encrypt payload :param sender_key: Sender's private key in case JWEAlgorithmWithTagAwareKeyAgreement is used :return: JWE compact serialization as bytes or JWE JSON serialization as dict rNrcr\)rxr[)r'r:rOrPrQr*r*r+ serializeszJsonWebEncryption.serializecCs|zt|}|d\}}}}} Wn tytdwt|t} t|td} t|td} t|td} t| td}|| }|| }|| }| ||| | |t |t rct |dkrc|d}t|| |}|d urr||}t |tr|jd ur||| | |||}n||| | ||}n||| | |}t|d }|| || ||}|r|t|}n|}|r||}| |d S) aExtract JWE Compact Serialization. :param s: JWE Compact Serialization as bytes :param key: Private key used to decrypt payload (optionally can be a tuple of kid and essentially key) :param decode: Function to decode payload data :param sender_key: Sender's public key in case JWEAlgorithmWithTagAwareKeyAgreement is used :return: dict with `header` and `payload` keys where `header` value is a dict containing protected header fields r=zNot enough segmentszencryption keyinitialization vectorrYauthentication tagr`Nr<r:rO)rrsplitr/rr r r>r?r@rArBrDtuplerhrCrrEunwrapdecrypt decompress)r'srPdecoderQ protected_sek_siv_s ciphertext_stag_srNr;rUrYrZrrrRr9rWrXrOr*r*r+deserialize_compactsD                  z%JsonWebEncryption.deserialize_compactcst|d}t|}d|vrtt|dtnd|d|dD]}d|vr.i|d<tt|dtd|d<q$d |vrJtt|d td }nd}tt|d td }tt|d td }tt|dtdt} || | | | | } | | | D] }| |dqdt trtdkrdddurjdurfdd} fdd} fdd} fdd}t trjdur|| }n || }n|| }t|dd}d |vr|dt|d 7}t|d}||||}| r-| t|}n|}|r6||}D]}|dsB|d=t|D] }|dkrR||=qHq8i}r_|d<rf|d<|d<|durs||d <||dS)a9Extract JWE JSON Serialization. :param obj: JWE JSON Serialization as dict or str :param key: Private key used to decrypt payload (optionally can be a tuple of kid and essentially key) :param decode: Function to decode payload data :param sender_key: Sender's public key in case JWEAlgorithmWithTagAwareKeyAgreement is used :return: dict with `header` and `payload` keys where `header` value is a dict containing `protected`, `unprotected`, `recipients` and/or `aad` keys r-rNNrcr\r:raz encrypted keyrWzJWE AADrUrzrYrZr{r|rr`cs||Sr$rr;r:)rrrPrQrZr*r+_unwrap_with_sender_key_and_tag#szKJsonWebEncryption.deserialize_json.._unwrap_with_sender_key_and_tagcs||Sr$rr)rrrPrQr*r+'_unwrap_with_sender_key_and_without_tag&szSJsonWebEncryption.deserialize_json.._unwrap_with_sender_key_and_without_tagcs||Sr$rr)rrrPr*r+"_unwrap_without_sender_key_and_tag)szNJsonWebEncryption.deserialize_json.._unwrap_without_sender_key_and_tagc sdur#D]}|ddkr"t|d}||d|Sqd}D](}t|d}z ||d|WStyO}z|}WYd}~q'd}~ww|durWt|)Nr:rra)rfr Exceptionr) unwrap_funcrsr:errore)rrNr\rcr*r+_unwrap_for_matching_recipient,s$zJJsonWebEncryption.deserialize_json.._unwrap_for_matching_recipientr=r<r})r rr rrrfr r r>r?r@rArBrDrrhrCrrrErrrmrn)r'rvrPrrQrsrrrUrYrprRrrrrr9rWrXrOrwr:r*) rrrPrrNr\rQrZrcr+deserialize_jsons                    z"JsonWebEncryption.deserialize_jsoncCsVt|tr |||||St|}|dr#|dr#|||||S|||||S)a%Extract a JWE Serialization. It supports both compact and JSON serialization. :param obj: JWE compact serialization as bytes or JWE JSON serialization as dict or str :param key: Private key used to decrypt payload (optionally can be a tuple of kid and essentially key) :param decode: Function to decode payload data :param sender_key: Sender's public key in case JWEAlgorithmWithTagAwareKeyAgreement is used :return: dict with `header` and `payload` keys {})rDdictrr startswithendswithr)r'rvrPrrQr*r*r+ deserializess zJsonWebEncryption.deserializecCs t|dS)zParse JWE JSON Serialization. :param obj: JWE JSON Serialization as str or dict :return: Parsed JWE JSON Serialization as dict if `obj` is an str, or `obj` as is if `obj` is already a dict r-)r )rvr*r*r+ parse_jsons zJsonWebEncryption.parse_jsoncCJd|vrt|d}|jdur||jvrt||jvr t|j|S)Nr)rr%rr1)r'r:rr*r*r+r>s  z JsonWebEncryption.get_header_algcCr)Nr)rr%rr3)r'r:rr*r*r+r?s  z JsonWebEncryption.get_header_enccCsHd|vr"|d}|jdur||jvrt||jvrt|j|SdS)Nr)r%rr4)r'r:zr*r*r+r@s  z JsonWebEncryption.get_header_zipcCsBt|tr|durtd|jdS|durtd|jdS)NzD{} algorithm requires sender_key but passed sender_key value is NonezL{} algorithm does not use sender_key but passed sender_key value is not None)rDrr/rir2)r'rQrr*r*r+rAs z&JsonWebEncryption._validate_sender_keycCsT|jdurdS|j}||j}|jr||j}|D] }||vr't|qdSr$)r&!REGISTERED_HEADER_PARAMETER_NAMEScopyunion EXTRA_HEADERSr)r'r:rnameskr*r*r+rBs    z+JsonWebEncryption._validate_private_headers)NNr$)__name__ __module__ __qualname__ frozensetrr1r3r4r, classmethodr7r[rxryrrr staticmethodrr>r?r@rArBr*r*r*r+rs.    ] w  B      rcCs6t|r ||d}n |durd|vr|d}||S)Nr)callablerC)rr:rPr*r*r+rCs   rCN) collectionsrrrauthlib.common.encodingrrrrauthlib.jose.rfc7516.modelsrr r authlib.jose.utilr r r authlib.jose.errorsrrrrrrrrrrrCr*r*r*r+s ,  ;