o
    _6dz                     @   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% g d	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/Z4d0ddZ5dd Z6dd Z7dZ8dZ9dZ:dd Z;d d! Z<d"d# Z
e5d$d%d&Z=e2d' Z>d(d) ZG d*d+ d+e?Z@G d,d- d-e@ZAeAe)ZBeAe)d.d/ZCeAe*d.d/ZDdS )1zC
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u rt dd }nt|trt|dksJ tt|}|  D ];\}}t|tr/t|}t|t	r@d|  kr?dk sBJ  J t|t
rL|d}t|trWt|dksYJ |||< q"t|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listr   itemsr   ordintr   encodeB_EMPTYjoin)mappingsourcetargetkv rE   kC:\Users\jesus\OneDrive\Desktop\erpjis_fastapi\backend\jisbackend\Lib\site-packages\passlib/utils/binary.pyr#   n   s   
&



r#   c                 C   s   t | tS )zr
    encode using shortened base64 format which omits padding & whitespace.
    uses default ``+/`` altchars.
    )r	   rstrip_BASE64_STRIPdatarE   rE   rF   r&      s   r&   c              
   C   s   t | trz| d} W n ty   ttdw t| d@ }|dkr%n|dkr.| t7 } n|dkr7| t7 } ntdzt	| W S  t
yR } ztt|d}~ww )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)rJ   offerrrE   rE   rF   r'      s(   



r'   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&   replacerI   rE   rE   rF   r$      s   r$   c                 C   sD   t | trz| d} W n ty   ttdw 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   rK   rW   rV   )r6   r   r=   rN   r   rO   r'   rX   rI   rE   rE   rF   r%      s   
r%   c                 C   s   t t| tS )zh
    wrapper around :func:`base64.b32encode` which strips padding,
    and returns a native string.
    )r   
_b32encoderG   B_EQUALrA   rE   rE   rF   r      s   r   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)rA   	remainderrE   rE   rF   r      s   



r   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r,td|| _	|j
| _tdd t|D }|j
| _|| _|rQ| j| _| j| _d S | 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 NrE   ).0idxvaluerE   rE   rF   	<genexpr>]      z(Base64Engine.__init__.<locals>.<genexpr>)r6   r   r=   r7   r   ZExpectedStringErrorr8   rO   setbytemap__getitem__	_encode64dict	enumerate	_decode64big_encode_bytes_big_encode_bytes_decode_bytes_big_decode_bytes_encode_bytes_little_decode_bytes_little)selfrh   rw   lookuprE   rE   rF   __init__Q  s$   

zBase64Engine.__init__c                 C   s   | j dS )zcharmap as unicoderg   )rq   decode)r~   rE   rE   rF   rh   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 %srL   c                 s   s    | ]}t |V  qd S rj   )r;   )rk   elemrE   rE   rF   rn         z,Base64Engine.encode_bytes.<locals>.<genexpr>)r6   r7   rS   typedivmodr8   r   r   iterry   r   r   rs   )r~   rA   chunkstail
next_valuegenoutrE   rE   rF   encode_bytes{  s   
zBase64Engine.encode_bytesc                 c   s    d}||k r8| }| }| }|d@ V  |d@ d> |d? B V  |d@ d> |d? B V  |d? V  |d7 }||k s|rm| }|dkrM|d@ V  |d? V  d	S |dksSJ | }|d@ V  |d@ d> |d? B V  |d? V  d	S d	S )
z>helper used by encode_bytes() to handle little-endian encodingr   ?      rM      rL      r4   NrE   r~   r   r   r   rl   v1v2v3rE   rE   rF   r|     s.   

	

z!Base64Engine._encode_bytes_littlec                 c   s    d}||k r8| }| }| }|d? V  |d@ d> |d? B V  |d@ d> |d? B V  |d@ V  |d7 }||k s|rq| }|dkrO|d? V  |d@ d> V  d	S |dksUJ | }|d? V  |d@ d> |d? B V  |d@ d> V  d	S d	S )
z;helper used by encode_bytes() to handle big-endian encodingr   rM   rL   r   r   r   r   r4   NrE   r   rE   rE   rF   rx     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yG } z
td|jd f d}~ww )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   rS   r   r   r8   rO   r   r   rv   r   r{   KeyErrorargs)r~   rA   r   r   r   rU   rE   rE   rF   decode_bytes  s   
zBase64Engine.decode_bytesc           	      c   s    d}||k r8| }| }| }| }||d@ d> B V  |d? |d@ d> B V  |d? |d> B V  |d7 }||k s|r]| }| }||d@ d> B V  |dkr_| }|d? |d@ d> B V  dS dS dS )	z>helper used by decode_bytes() to handle little-endian encodingr   rL   r   rM   r   r   r4   NrE   	r~   r   r   r   rl   r   r   r   Zv4rE   rE   rF   r}     *   	z!Base64Engine._decode_bytes_littlec           	      c   s    d}||k r8| }| }| }| }|d> |d? B V  |d@ d> |d? B V  |d@ d> |B V  |d7 }||k s|r]| }| }|d> |d? B V  |dkr_| }|d@ d> |d? B V  dS dS dS )	z;helper used by decode_bytes() to handle big-endian encodingr   rM   r   r   rL   r   r4   NrE   r   rE   rE   rF   rz     r   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|V  qd S rj   rE   rk   icbitsrE   rF   rn   G      z-Base64Engine.__make_padset.<locals>.<genexpr>c                 3   r   rj   rE   r   r   rE   rF   rn   H  r   )rp   ru   rq   updaterh   	frozenset)r~   r   ZpsetrE   r   rF   Z__make_padsetE  s   zBase64Engine.__make_padsetc                 C      | j rdnd}| | |fS )zDmask to clear padding bits, and valid last bytes (for strings 2 % 4)r   <   rw   _Base64Engine__make_padsetr~   r   rE   rE   rF   	_padinfo2K     zBase64Engine._padinfo2c                 C   r   )zDmask to clear padding bits, and valid last bytes (for strings 3 % 4)rL   0   r   r   rE   rE   rF   	_padinfo3R  r   zBase64Engine._padinfo3c                 C   s   t |d@ }|dkr| j\}}n|dkr| j\}}n
|s d|fS td|d }||v r0d|fS t|trJ| j}||||@  }||v sIJ dn| | 	||@ }||v s\J dt
rct|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.
        rL   rM   Fzsource length must != 1 mod 4z%failed to generate valid padding charTN)r8   r   r   rO   r6   r   rh   indexrs   rv   r   r7   )r~   rA   r   maskZpadsetlastcmrE   rE   rF   check_repair_unusedY  s(   

z Base64Engine.check_repair_unusedc                 C   s   |  |d S )Nr4   )r   r~   rA   rE   rE   rF   repair_unused     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 rj   rE   rk   rT   r[   rE   rF   rn     r   z7Base64Engine.encode_transposed_bytes.<locals>.<genexpr>)r6   r7   rS   r   r   r   )r~   rA   offsetstmprE   r[   rF   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~   rA   r   r   bufrT   charrE   rE   rF   decode_transposed_bytes  s
   

z$Base64Engine.decode_transposed_bytesc           	      C   s   t |tstdt|f | j}| d }|| d }t||kr)td|f | j}d}z|r3|nt|D ]
}|d> || }q7W n t	yQ   td|f w |rd|r\||L }|S |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   rS   r   rw   r8   rO   rv   reversedr   )	r~   rA   r   rw   padcharsr   r   r   rE   rE   rF   _decode_int  s,   

zBase64Engine._decode_intc                 C   s`   t |tstdt|f t|dkrtdtr|d }z| |W S  ty/   tdw )z(decode single character -> 6 bit integerr   r4   zsource must be exactly 1 byter   invalid character)	r6   r7   rS   r   r8   rO   r   rv   r   r   rE   rE   rF   decode_int6  s   
zBase64Engine.decode_int6c                 C   s   t |tstdt|f t|dkrtd| j}z!| jr.||d ||d d>  W S ||d ||d d>  W S  tyG   tdw )z'decodes 2 char string -> 12-bit integerr   rM   zsource must be exactly 2 bytesr4   r   r   r   	r6   r7   rS   r   r8   rO   rv   rw   r   r~   rA   r   rE   rE   rF   decode_int12  s   
zBase64Engine.decode_int12c                 C   s   t |tstdt|f t|dkrtd| j}zA| jr>||d ||d d>  ||d d>  ||d	 d
>  W S ||d	 ||d d>  ||d d>  ||d d
>  W S  tyg   tdw )z'decodes 4 char string -> 24-bit integerr   r   zsource must be exactly 4 bytesrL   rM   r   r4      r      r   r   r   rE   rE   rF   decode_int24  s(   
zBase64Engine.decode_int24c                 C      |  |dS )&decode 5 char string -> 30 bit integer   r   r   rE   rE   rF   decode_int30  s   zBase64Engine.decode_int30c                 C   r   )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.
        ri   r   r   rE   rE   rF   decode_int64  s   zBase64Engine.decode_int64c                    sl    dksJ d| d }||7 }| j r!t|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   NrE   r   rm   rE   rF   rn   "  ro   z+Base64Engine._encode_int.<locals>.<genexpr>)rw   r   r   r   rs   )r~   rm   r   r   itrrE   r   rF   _encode_int  s   	

zBase64Engine._encode_intc                 C   s8   |dk s|dkrt dtr| j||d  S | |S )z0encodes 6-bit integer -> single hash64 characterr   r   value out of ranger4   )rO   r   rq   rs   r~   rm   rE   rE   rF   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   rO   rw   r   r   r   rs   r~   rm   rawrE   rE   rF   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r't|}tt| j|S )z'encodes 24-bit integer -> 4 char stringr   i r   r   r   r   r   r   r   rE   rE   rF   encode_int24:  s   zBase64Engine.encode_int24c                 C   $   |dk s|dkrt d| |dS )r   r   i?r   r   rO   r   r   rE   rE   rF   encode_int30D  s   zBase64Engine.encode_int30c                 C   r   )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   ri   r   r   rE   rE   rF   encode_int64J  s   zBase64Engine.encode_int64)F)'__name__
__module____qualname____doc__rq   rw   rs   rv   ry   r{   r   propertyrh   r   r|   rx   r   r}   rz   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rE   rE   rE   rF   r(      sL    D
"
'+#*

)(		
r(   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 rj   )
_lazy_optsr~   r   kwdsrE   rE   rF   r   \  r   zLazyBase64Engine.__init__c                    s.   | j \}}tt| j|i | | ` t| _d S rj   )r   superr)   r   r(   	__class__r   r   rE   rF   
_lazy_init_  s   

zLazyBase64Engine._lazy_initc                 C   s   | ds	|   t| |S )N_)
startswithr   object__getattribute__)r~   attrrE   rE   rF   r   e  s   
z!LazyBase64Engine.__getattribute__)	r   r   r   r   r   r   r   r   __classcell__rE   rE   r   rF   r)   X  s    r)   T)rw   rj   )Er   
__future__r   r   r   base64r   r   r   re   r   rY   binasciir	   r
   r   rR   logging	getLoggerr   logZpasslibr   Zpasslib.utils.compatr   r   r   r   r   r   r   r   r   r   r   r   Zpasslib.utils.decorr   __all__r   r   r   r   r   r   r!   r    r"   r>   ZB_NULLrZ   r9   r5   r#   r&   r'   rH   rQ   rP   r$   r%   rc   rd   r   r(   r)   r*   r+   r,   rE   rE   rE   rF   <module>   sX    
8%
!	    _