o
    5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% 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=0123456789abcdefABCDEF0123456789ABCDEF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   r1   ascii   )_TRANSLATE_SOURCE
isinstancebyteslenlistr   itemsr   ordintr   encodeB_EMPTYjoin)mappingsourcetargetkv rH   h/var/www/html/construction_image-detection-poc/venv/lib/python3.10/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datarH   rH   rI   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.
    r6   4string argument should contain only ASCII characters   r      zinvalid base64 inputN)r9   r   r@   UnicodeEncodeErrorr   
ValueErrorr;   _BASE64_PAD2_BASE64_PAD1r
   _BinAsciiError	TypeError)rM   offerrrH   rH   rI   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&   replacerL   rH   rH   rI   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.
    r6   rN   rZ   rY   )r9   r   r@   rQ   r   rR   r'   r[   rL   rH   rH   rI   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   
_b32encoderJ   B_EQUALrD   rH   rH   rI   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.
    r6      NT)r9   r   r@   	translate_b32_translater;   _b32_decode_pad
_b32decode)rD   	remainderrH   rH   rI   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 NrH   ).0idxvaluerH   rH   rI   	<genexpr>]      z(Base64Engine.__init__.<locals>.<genexpr>)r9   r   r@   r:   r   ExpectedStringErrorr;   rR   setbytemap__getitem__	_encode64dict	enumerate	_decode64big_encode_bytes_big_encode_bytes_decode_bytes_big_decode_bytes_encode_bytes_little_decode_bytes_little)selfrk   r{   lookuprH   rH   rI   __init__Q  s$   

zBase64Engine.__init__c                 C   s   | j dS )zcharmap as unicoderj   )ru   decode)r   rH   rH   rI   rk   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 %srO   c                 s   s    | ]}t |V  qd S rm   )r>   )rn   elemrH   rH   rI   rq         z,Base64Engine.encode_bytes.<locals>.<genexpr>)r9   r:   rV   typedivmodr;   r   r   iterr}   r   r   rw   )r   rD   chunkstail
next_valuegenoutrH   rH   rI   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   ?      rP      rO      r7   NrH   r   r   r   r   ro   v1v2v3rH   rH   rI   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   rP   rO   r   r   r   r   r7   NrH   r   rH   rH   rI   r|     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   r7   z(input string length cannot be == 1 mod 4zinvalid character: %rr   N)r9   r:   rV   r   r   r;   rR   r   r   rz   r   r   KeyErrorargs)r   rD   r   r   r   rX   rH   rH   rI   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   rO   r   rP   r   r   r7   NrH   	r   r   r   r   ro   r   r   r   v4rH   rH   rI   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   rP   r   r   rO   r   r7   NrH   r   rH   rH   rI   r~     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 rm   rH   rn   icbitsrH   rI   rq   G      z-Base64Engine.__make_padset.<locals>.<genexpr>c                 3   r   rm   rH   r   r   rH   rI   rq   H  r   )rt   ry   ru   updaterk   	frozenset)r   r   psetrH   r   rI   __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   <   r{   _Base64Engine__make_padsetr   r   rH   rH   rI   	_padinfo2K     zBase64Engine._padinfo2c                 C   r   )zDmask to clear padding bits, and valid last bytes (for strings 3 % 4)rO   0   r   r   rH   rH   rI   	_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.
        rO   rP   Fzsource length must != 1 mod 4z%failed to generate valid padding charTN)r;   r   r   rR   r9   r   rk   indexrw   rz   r   r:   )r   rD   r   maskpadsetlastcmrH   rH   rI   check_repair_unusedY  s(   

z Base64Engine.check_repair_unusedc                 C   s   |  |d S )Nr7   )r   r   rD   rH   rH   rI   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 rm   rH   rn   rW   r^   rH   rI   rq     r   z7Base64Engine.encode_transposed_bytes.<locals>.<genexpr>)r9   r:   rV   r   r   r   )r   rD   offsetstmprH   r^   rI   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   r;   zipr   )r   rD   r   r   bufrW   charrH   rH   rI   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: %rr7   )
r9   r:   rV   r   r{   r;   rR   rz   reversedr   )	r   rD   r   r{   padcharsr   r   r   rH   rH   rI   _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   r7   zsource must be exactly 1 byter   invalid character)	r9   r:   rV   r   r;   rR   r   rz   r   r   rH   rH   rI   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   rP   zsource must be exactly 2 bytesr7   r   r   r   	r9   r:   rV   r   r;   rR   rz   r{   r   r   rD   r   rH   rH   rI   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 bytesrO   rP   r   r7      r      r   r   r   rH   rH   rI   decode_int24  s(   
zBase64Engine.decode_int24c                 C      |  |dS )&decode 5 char string -> 30 bit integer   r   r   rH   rH   rI   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.
        rl   r   r   rH   rH   rI   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   NrH   r   rp   rH   rI   rq   "  rr   z+Base64Engine._encode_int.<locals>.<genexpr>)r{   r   r   r   rw   )r   rp   r   r   itrrH   r   rI   _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 ranger7   )rR   r   ru   rw   r   rp   rH   rH   rI   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   rR   r{   r   r   r   rw   r   rp   rawrH   rH   rI   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   rH   rH   rI   encode_int24:  s   zBase64Engine.encode_int24c                 C   $   |dk s|dkrt d| |dS )r   r   i?r   r   rR   r   r   rH   rH   rI   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   rl   r   r   rH   rH   rI   encode_int64J  s   zBase64Engine.encode_int64)F)'__name__
__module____qualname____doc__ru   r{   rw   rz   r}   r   r   propertyrk   r   r   r|   r   r   r~   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rH   rH   rH   rI   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 rm   )
_lazy_optsr   r   kwdsrH   rH   rI   r   \  r   zLazyBase64Engine.__init__c                    s.   | j \}}tt| j|i | | ` t| _d S rm   )r   superr)   r   r(   	__class__r   r   rH   rI   
_lazy_init_  s   

zLazyBase64Engine._lazy_initc                 C   s   | ds	|   t| |S )N_)
startswithr   object__getattribute__)r   attrrH   rH   rI   r   e  s   
z!LazyBase64Engine.__getattribute__)	r   r   r   r   r   r   r   r   __classcell__rH   rH   r   rI   r)   X  s    r)   T)r{   rm   )Er   
__future__r   r   r   base64r   r   r   rh   r   r\   binasciir	   r
   r   rU   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"   rA   B_NULLr]   r<   r8   r#   r&   r'   rK   rT   rS   r$   r%   rf   rg   r   r(   r)   r*   r+   r,   rH   rH   rH   rI   <module>   sX    
8%
!	    _