U
    hz                     @   s  d Z ddlmZmZmZ ddlmZmZmZ	m
Z ddlmZmZmZ ddlZeeZddlmZ ddlmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z# ddl$m%Z% d	d
dddddddddddddddddddgZ&e!dZ'e!dZ(e!d Z)e!d!Z*e'e!d" Z+e!d#Z,e!d$Z-e!d%Z.eed&Z/d'Z0d(Z1d)Z2e3ee/Z4d;d*dZ5d+d Z6d,d Z7d-Z8d)Z9d.Z:d/d Z;d0d Z<d1d Z
e5d2d3d4Z=e2d5 Z>d6d ZG d7d de?Z@G d8d de@ZAeAe)ZBeAe)d9d:ZCeAe*d9d:ZDdS )<zC
passlib.utils.binary - binary data encoding/decoding/manipulation
    )absolute_importdivisionprint_function)	b64encode	b64decode	b32decode	b32encode)
b2a_base64
a2b_base64ErrorN)exc)PY3bascii_to_strirangeimapiter_byte_charsjoin_byte_valuesjoin_byte_elems
nextgettersuppress_causeuunicodeunicode_or_bytes_types)memoized_propertyBASE64_CHARSPADDED_BASE64_CHARS
AB64_CHARSHASH64_CHARSBCRYPT_CHARS	HEX_CHARSLOWER_HEX_CHARSUPPER_HEX_CHARSALL_BYTE_VALUEScompile_byte_translationab64_encodeab64_decodeb64s_encodeb64s_decoder   r   Base64EngineLazyBase64Engineh64h64bigbcrypt64z@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/z@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789./z@./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzz@./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789=Z0123456789abcdefABCDEFZ0123456789ABCDEFZ0123456789abcdef              =c                 C   s   |dkrt dd }n&t|tr,t|dks0ttt|}|  D ]t\}}t|tr^t	|}t|t
r~d|  kr|dk sn tt|tr|d}t|trt|dkst|||< qDt|S )a  
    return a 256-byte string for translating bytes using specified mapping.
    bytes not specified by mapping will be left alone.

    :param mapping:
        dict mapping input byte (str or int) -> output byte (str or int).

    :param source:
        optional existing byte translation string to use as base.
        (must be 255-length byte string).  defaults to identity mapping.

    :returns:
        255-length byte string for passing to bytes().translate.
    N   r   r.   ascii   )_TRANSLATE_SOURCE
isinstancebyteslenAssertionErrorlistr   itemsr   ordintr   encodeB_EMPTYjoin)mappingsourcetargetkv rF   X/var/www/html/timesheet/backend/venv/lib/python3.8/site-packages/passlib/utils/binary.pyr#   n   s    
$


c                 C   s   t | tS )zr
    encode using shortened base64 format which omits padding & whitespace.
    uses default ``+/`` altchars.
    )r	   rstrip_BASE64_STRIPdatarF   rF   rG   r&      s    c              
   C   s   t | tr:z| d} W n  tk
r8   ttdY nX t| d@ }|dkrPn,|dkrb| t7 } n|dkrt| t7 } ntdz
t	| W S  t
k
r } ztt|W 5 d}~X Y nX dS )zq
    decode from shortened base64 format which omits padding & whitespace.
    uses default ``+/`` altchars.
    r3   4string argument should contain only ASCII characters   r      zinvalid base64 inputN)r6   r   r>   UnicodeEncodeErrorr   
ValueErrorr8   _BASE64_PAD2_BASE64_PAD1r
   _BinAsciiError	TypeError)rK   offerrrF   rF   rG   r'      s"    



s   =
s   ==c                 C   s   t | ddS )z
    encode using shortened base64 format which omits padding & whitespace.
    uses custom ``./`` altchars.

    it is primarily used by Passlib's custom pbkdf2 hashes.
       +   .)r&   replacerJ   rF   rF   rG   r$      s    c                 C   sJ   t | tr:z| d} W n  tk
r8   ttdY nX t| ddS )z
    decode from shortened base64 format which omits padding & whitespace.
    uses custom ``./`` altchars, but supports decoding normal ``+/`` altchars as well.

    it is primarily used by Passlib's custom pbkdf2 hashes.
    r3   rL   rX   rW   )r6   r   r>   rO   r   rP   r'   rY   rJ   rF   rF   rG   r%      s    
c                 C   s   t t| tS )zh
    wrapper around :func:`base64.b32encode` which strips padding,
    and returns a native string.
    )r   
_b32encoderH   B_EQUALrB   rF   rF   rG   r      s    BO)80   c                 C   sJ   t | tr| d} | t} t| d@ }|r@| td|  7 } t| dS )z
    wrapper around :func:`base64.b32decode`
    which handles common mistyped chars.
    padding optional, ignored if present.
    r3      NT)r6   r   r>   	translate_b32_translater8   _b32_decode_pad
_b32decode)rB   	remainderrF   rF   rG   r      s    


c                   @   s  e Zd ZdZdZdZdZdZdZdZ	d:ddZ
edd Zdd	 Zd
d Zdd Zdd Zdd Zdd Zdd Zedd Zedd Zdd Zdd Zdd Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd*d+ Zd,d- Z d.d/ Z!d0d1 Z"d2d3 Z#d4d5 Z$d6d7 Z%d8d9 Z&dS );r(   ac  Provides routines for encoding/decoding base64 data using
    arbitrary character mappings, selectable endianness, etc.

    :arg charmap:
        A string of 64 unique characters,
        which will be used to encode successive 6-bit chunks of data.
        A character's position within the string should correspond
        to its 6-bit value.

    :param big:
        Whether the encoding should be big-endian (default False).

    .. note::
        This class does not currently handle base64's padding characters
        in any way what so ever.

    Raw Bytes <-> Encoded Bytes
    ===========================
    The following methods convert between raw bytes,
    and strings encoded using the engine's specific base64 variant:

    .. automethod:: encode_bytes
    .. automethod:: decode_bytes
    .. automethod:: encode_transposed_bytes
    .. automethod:: decode_transposed_bytes

    ..
        .. automethod:: check_repair_unused
        .. automethod:: repair_unused

    Integers <-> Encoded Bytes
    ==========================
    The following methods allow encoding and decoding
    unsigned integers to and from the engine's specific base64 variant.
    Endianess is determined by the engine's ``big`` constructor keyword.

    .. automethod:: encode_int6
    .. automethod:: decode_int6

    .. automethod:: encode_int12
    .. automethod:: decode_int12

    .. automethod:: encode_int24
    .. automethod:: decode_int24

    .. automethod:: encode_int64
    .. automethod:: decode_int64

    Informational Attributes
    ========================
    .. attribute:: charmap

        unicode string containing list of characters used in encoding;
        position in string matches 6bit value of character.

    .. attribute:: bytemap

        bytes version of :attr:`charmap`

    .. attribute:: big

        boolean flag indicating this using big-endian encoding.
    NFc                 C   s   t |tr|d}nt |ts,t|dt|dkr@tdtt|dkrXtd|| _	|j
| _tdd t|D }|j
| _|| _|r| j| _| j| _n| j| _| j| _d S )Nlatin-1charmap@   z'charmap must be 64 characters in lengthz-charmap must not contain duplicate charactersc                 s   s   | ]\}}||fV  qd S NrF   ).0idxvaluerF   rF   rG   	<genexpr>]  s     z(Base64Engine.__init__.<locals>.<genexpr>)r6   r   r>   r7   r   ExpectedStringErrorr8   rP   setbytemap__getitem__	_encode64dict	enumerate	_decode64big_encode_bytes_big_encode_bytes_decode_bytes_big_decode_bytes_encode_bytes_little_decode_bytes_little)selfri   rx   lookuprF   rF   rG   __init__Q  s$    


zBase64Engine.__init__c                 C   s   | j dS )zcharmap as unicoderh   )rr   decode)r   rF   rF   rG   ri   s  s    zBase64Engine.charmapc                 C   st   t |tstdt|f tt|d\}}tr@tt|}ntdd |D }| 	|||}t
t| j|}|S )zencode bytes to base64 string.

        :arg source: byte string to encode.
        :returns: byte string containing encoded data.
        source must be bytes, not %srM   c                 s   s   | ]}t |V  qd S rk   )r<   )rl   elemrF   rF   rG   ro     s     z,Base64Engine.encode_bytes.<locals>.<genexpr>)r6   r7   rT   typedivmodr8   r   r   iterrz   r   r   rt   )r   rB   chunkstail
next_valuegenoutrF   rF   rG   encode_bytes{  s    
zBase64Engine.encode_bytesc                 c   s   d}||k rh| }| }| }|d@ V  |d@ d> |d? B V  |d@ d> |d? B V  |d? V  |d7 }q|r| }|dkr|d@ V  |d? V  n<|dkst | }|d@ V  |d@ d> |d? B V  |d? V  d	S )
z>helper used by encode_bytes() to handle little-endian encodingr   ?      rN      rM      r4   Nr9   r   r   r   r   rm   v1v2v3rF   rF   rG   r}     s(    




z!Base64Engine._encode_bytes_littlec                 c   s   d}||k rh| }| }| }|d? V  |d@ d> |d? B V  |d@ d> |d? B V  |d@ V  |d7 }q|r| }|dkr|d? V  |d@ d> V  n@|dkst | }|d? V  |d@ d> |d? B V  |d@ d> V  d	S )
z;helper used by encode_bytes() to handle big-endian encodingr   rN   rM   r   r   r   r   r4   Nr   r   rF   rF   rG   ry     s(    




zBase64Engine._encode_bytes_bigc              
   C   s   t |tstdt|f tt|d\}}|dkr>tdtt| j	|}zt
| |||W S  tk
r } ztd|jd f W 5 d}~X Y nX dS )zdecode bytes from base64 string.

        :arg source: byte string to decode.
        :returns: byte string containing decoded data.
        r   r   r4   z(input string length cannot be == 1 mod 4zinvalid character: %rr   N)r6   r7   rT   r   r   r8   rP   r   r   rw   r   r|   KeyErrorargs)r   rB   r   r   r   rV   rF   rF   rG   decode_bytes  s    
zBase64Engine.decode_bytesc           	      c   s   d}||k rh| }| }| }| }||d@ d> B V  |d? |d@ d> B V  |d? |d> B V  |d7 }q|r| }| }||d@ d> B V  |dkr| }|d? |d@ d> B V  dS )	z>helper used by decode_bytes() to handle little-endian encodingr   rM   r   rN   r   r   r4   NrF   	r   r   r   r   rm   r   r   r   Zv4rF   rF   rG   r~     s"    
z!Base64Engine._decode_bytes_littlec           	      c   s   d}||k rh| }| }| }| }|d> |d? B V  |d@ d> |d? B V  |d@ d> |B V  |d7 }q|r| }| }|d> |d? B V  |dkr| }|d@ d> |d? B V  dS )	z;helper used by decode_bytes() to handle big-endian encodingr   rN   r   r   rM   r   r4   NrF   r   rF   rF   rG   r{     s"    
zBase64Engine._decode_bytes_bigc                    sB   t  fddt| jD }| fddt| jD  t|S )z2helper to generate set of valid last chars & bytesc                 3   s   | ]\}}| @ s|V  qd S rk   rF   rl   icbitsrF   rG   ro   G  s      z-Base64Engine.__make_padset.<locals>.<genexpr>c                 3   s   | ]\}}| @ s|V  qd S rk   rF   r   r   rF   rG   ro   H  s      )rq   rv   rr   updateri   	frozenset)r   r   ZpsetrF   r   rG   Z__make_padsetE  s    zBase64Engine.__make_padsetc                 C   s   | j r
dnd}| | |fS )zDmask to clear padding bits, and valid last bytes (for strings 2 % 4)r   <   rx   _Base64Engine__make_padsetr   r   rF   rF   rG   	_padinfo2K  s    zBase64Engine._padinfo2c                 C   s   | j r
dnd}| | |fS )zDmask to clear padding bits, and valid last bytes (for strings 3 % 4)rM   0   r   r   rF   rF   rG   	_padinfo3R  s    zBase64Engine._padinfo3c                 C   s   t |d@ }|dkr | j\}}n(|dkr4| j\}}n|s@d|fS td|d }||kr`d|fS t|tr| j}||||@  }||kstdn2| 	| 
||@ }||kstdtrt|g}d|dd | fS )	a  helper to detect & clear invalid unused bits in last character.

        :arg source:
            encoded data (as ascii bytes or unicode).

        :returns:
            `(True, result)` if the string was repaired,
            `(False, source)` if the string was ok as-is.
        rM   rN   Fzsource length must != 1 mod 4z%failed to generate valid padding charTN)r8   r   r   rP   r6   r   ri   indexr9   rt   rw   r   r7   )r   rB   r   maskZpadsetlastcmrF   rF   rG   check_repair_unusedY  s(    

z Base64Engine.check_repair_unusedc                 C   s   |  |d S )Nr4   )r   r   rB   rF   rF   rG   repair_unused  s    zBase64Engine.repair_unusedc                    s<   t  tstdt f t fdd|D }| |S )z>encode byte string, first transposing source using offset listr   c                 3   s   | ]} | V  qd S rk   rF   rl   rU   r\   rF   rG   ro     s     z7Base64Engine.encode_transposed_bytes.<locals>.<genexpr>)r6   r7   rT   r   r   r   )r   rB   offsetstmprF   r\   rG   encode_transposed_bytes  s    
z$Base64Engine.encode_transposed_bytesc                 C   s<   |  |}dgt| }t||D ]\}}|||< q"t|S )zGdecode byte string, then reverse transposition described by offset listN)r   r8   zipr   )r   rB   r   r   bufrU   charrF   rF   rG   decode_transposed_bytes  s
    

z$Base64Engine.decode_transposed_bytesc           	      C   s   t |tstdt|f | j}| d }|| d }t||krRtd|f | j}d}z*|rf|nt|D ]}|d> || }qnW n" t	k
r   td|f Y nX |r|r||L }n|d|> d M }|S )a  decode base64 string -> integer

        :arg source: base64 string to decode.
        :arg bits: number of bits in resulting integer.

        :raises ValueError:
            * if the string contains invalid base64 characters.
            * if the string is not long enough - it must be at least
              ``int(ceil(bits/6))`` in length.

        :returns:
            a integer in the range ``0 <= n < 2**bits``
        r   r   zsource must be %d charsr   zinvalid character in string: %rr4   )
r6   r7   rT   r   rx   r8   rP   rw   reversedr   )	r   rB   r   rx   padcharsr   r   r   rF   rF   rG   _decode_int  s&    


zBase64Engine._decode_intc                 C   sj   t |tstdt|f t|dkr0tdtr<|d }z| |W S  tk
rd   tdY nX dS )z(decode single character -> 6 bit integerr   r4   zsource must be exactly 1 byter   invalid characterN)	r6   r7   rT   r   r8   rP   r   rw   r   r   rF   rF   rG   decode_int6  s    
zBase64Engine.decode_int6c                 C   s   t |tstdt|f t|dkr0td| j}zF| jr\||d ||d d>  W S ||d ||d d>  W S W n tk
r   tdY nX dS )	z'decodes 2 char string -> 12-bit integerr   rN   zsource must be exactly 2 bytesr4   r   r   r   N	r6   r7   rT   r   r8   rP   rw   rx   r   r   rB   r   rF   rF   rG   decode_int12  s    
"zBase64Engine.decode_int12c                 C   s   t |tstdt|f t|dkr0td| j}z| jr|||d ||d d>  ||d d>  ||d	 d
>  W S ||d	 ||d d>  ||d d>  ||d d
>  W S W n tk
r   tdY nX dS )z'decodes 4 char string -> 24-bit integerr   r   zsource must be exactly 4 bytesrM   rN   r   r4      r      r   Nr   r   rF   rF   rG   decode_int24  s&    

zBase64Engine.decode_int24c                 C   s   |  |dS )&decode 5 char string -> 30 bit integer   r   r   rF   rF   rG   decode_int30  s    zBase64Engine.decode_int30c                 C   s   |  |dS )zdecode 11 char base64 string -> 64-bit integer

        this format is used primarily by des-crypt & variants to encode
        the DES output value used as a checksum.
        rj   r   r   rF   rF   rG   decode_int64  s    zBase64Engine.decode_int64c                    sl    dkst d| d }||7 }| jrBt|d dd} |K  ntd|d}tt| j fdd|D S )zencode integer into base64 format

        :arg value: non-negative integer to encode
        :arg bits: number of bits to encode

        :returns:
            a string of length ``int(ceil(bits/6.0))``.
        r   zcaller did not sanitize inputr   ic                 3   s   | ]} |? d @ V  qdS )r   NrF   r   rn   rF   rG   ro   "  s     z+Base64Engine._encode_int.<locals>.<genexpr>)r9   rx   r   r   r   rt   )r   rn   r   r   itrrF   r   rG   _encode_int  s    	

zBase64Engine._encode_intc                 C   s<   |dk s|dkrt dtr.| j||d  S | |S dS )z0encodes 6-bit integer -> single hash64 characterr   r   value out of ranger4   N)rP   r   rr   rt   r   rn   rF   rF   rG   encode_int6(  s
    zBase64Engine.encode_int6c                 C   sJ   |dk s|dkrt d|d@ |d? d@ g}| jr:t|}tt| j|S )z'encodes 12-bit integer -> 2 char stringr   i  r   r   r   rP   rx   r   r   r   rt   r   rn   rawrF   rF   rG   encode_int121  s    zBase64Engine.encode_int12c                 C   s^   |dk s|dkrt d|d@ |d? d@ |d? d@ |d? d@ g}| jrNt|}tt| j|S )z'encodes 24-bit integer -> 4 char stringr   i r   r   r   r   r   r   r   rF   rF   rG   encode_int24:  s    
 
zBase64Engine.encode_int24c                 C   s$   |dk s|dkrt d| |dS )r   r   i?r   r   rP   r   r   rF   rF   rG   encode_int30D  s    zBase64Engine.encode_int30c                 C   s$   |dk s|dkrt d| |dS )zencode 64-bit integer -> 11 char hash64 string

        this format is used primarily by des-crypt & variants to encode
        the DES output value used as a checksum.
        r   l    r   rj   r   r   rF   rF   rG   encode_int64J  s    zBase64Engine.encode_int64)F)'__name__
__module____qualname____doc__rr   rx   rt   rw   rz   r|   r   propertyri   r   r}   ry   r   r~   r{   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rF   rF   rF   rG   r(      sJ   D
"
'+#*

)(		
c                       s4   e Zd ZdZdZdd Z fddZdd Z  ZS )	r)   z<Base64Engine which delays initialization until it's accessedNc                 O   s   ||f| _ d S rk   )
_lazy_optsr   r   kwdsrF   rF   rG   r   \  s    zLazyBase64Engine.__init__c                    s*   | j \}}tt| j|| | ` t| _d S rk   )r   superr)   r   r(   	__class__r   r   rF   rG   
_lazy_init_  s    
zLazyBase64Engine._lazy_initc                 C   s   | ds|   t| |S )N_)
startswithr   object__getattribute__)r   attrrF   rF   rG   r   e  s    
z!LazyBase64Engine.__getattribute__)	r   r   r   r   r   r   r   r   __classcell__rF   rF   r   rG   r)   X  s
   T)rx   )N)Er   
__future__r   r   r   base64r   r   r   rf   r   rZ   binasciir	   r
   r   rS   logging	getLoggerr   logpasslibr   passlib.utils.compatr   r   r   r   r   r   r   r   r   r   r   r   passlib.utils.decorr   __all__r   r   r   r   r   r   r!   r    r"   r?   ZB_NULLr[   r:   r5   r#   r&   r'   rI   rR   rQ   r$   r%   rd   re   r   r(   r)   r*   r+   r,   rF   rF   rF   rG   <module>   s   
8      %
!	    _