
     hz                     R   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j$                  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   Z+ e!d      Z, e!d      Z- e!d      Z. e ed            Z/dZ0dZ1dZ2 e3 ee/            Z4d)dZ5d Z6d Z7dZ8dZ9dZ:d Z;d Z<d Z
 e5ddd       Z=e2d!z  Z>d" Z G d# d$e?      Z@ G d% d&e@      ZA eAe)      ZB eAe)d'(      ZC eAe*d'(      ZDy)*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=0123456789abcdefABCDEF0123456789ABCDEF0123456789abcdef              =c                    |
t         dd }n4t        |t              rt        |      dk(  sJ t	        t        |            }| j                         D ]  \  }}t        |t              rt        |      }t        |t              rd|cxk  rdk  sJ  J t        |t              r|j                  d      }t        |t              rt        |      dk(  sJ |||<    t        j                  |      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   r2   ascii   )_TRANSLATE_SOURCE
isinstancebyteslenlistr   itemsr   ordintr   encodeB_EMPTYjoin)mappingsourcetargetkvs        V/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/passlib/utils/binary.pyr$   r$   n   s     ~"1%&%(S[C-??of-. 1a/0AA!S!a1lsl2l2a!!A!U#A!3q	 <<r3   c                 >    t        |       j                  t              S )zr
    encode using shortened base64 format which omits padding & whitespace.
    uses default ``+/`` altchars.
    )r
   rstrip_BASE64_STRIPdatas    rJ   r'   r'      s    
 d""=11r3   c                 d   t        | t              r	 | j                  d      } t        |       dz  }|dk(  rn)|dk(  r
| t        z  } n|dk(  r
| t        z  } nt        d      	 t        |       S # t        $ r t	        t        d            w xY w# t        $ r}t	        t        |            d}~ww xY w)zq
    decode from shortened base64 format which omits padding & whitespace.
    uses default ``+/`` altchars.
    r8   4string argument should contain only ASCII characters   r      zinvalid base64 inputN)r;   r   rB   UnicodeEncodeErrorr   
ValueErrorr=   _BASE64_PAD2_BASE64_PAD1r   _BinAsciiError	TypeError)rO   offerrs      rJ   r(   r(      s    
 $ 	e;;w'D d)a-C
ax		/00-$ " 	e ,b!cdd	e  -Ys^,,-s#   A, !
B ,B
	B/B**B/s   =
s   ==c                 8    t        |       j                  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'   replacerN   s    rJ   r%   r%      s     t$$T400r3   c                     t        | t              r	 | j                  d      } t        | j                  dd            S # t        $ r t	        t        d            w xY w)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.
    r8   rQ   r^   r]   )r;   r   rB   rT   r   rU   r(   r_   rN   s    rJ   r&   r&      s^     $ 	e;;w'D t||D$/00 " 	e ,b!cdd	es	   > Ac                 P    t        t        |       j                  t                    S )zh
    wrapper around :func:`base64.b32encode` which strips padding,
    and returns a native string.
    )r   
_b32encoderL   B_EQUAL)rF   s    rJ   r	   r	      s     F+227;<<r3   BO)80   c                     t        | t              r| j                  d      } | j                  t              } t        |       dz  }|r| t        d|  z  } t        | d      S )z
    wrapper around :func:`base64.b32decode`
    which handles common mistyped chars.
    padding optional, ignored if present.
    r8      NT)r;   r   rB   	translate_b32_translater=   _b32_decode_pad
_b32decode)rF   	remainders     rJ   r   r      sa     &'"w'n-F Fc!I/+I:.. fd##r3   c                       e Zd ZdZdZdZdZdZdZdZ	ddZ
ed        Zd Zd Zd Zd Zd	 Zd
 Zd Zed        Zed        Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Z d Z!d Z"d Z#d Z$d Z%d Z&y)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.
    Nc                 .   t        |t              r|j                  d      }n&t        |t              st	        j
                  |d      t        |      dk7  rt        d      t        t        |            dk7  rt        d      || _	        |j                  | _        t        d t        |      D              }|j                  | _        || _        |r#| j                   | _        | j$                  | _        y | j(                  | _        | j*                  | _        y )Nlatin-1charmap@   z'charmap must be 64 characters in lengthz-charmap must not contain duplicate charactersc              3   *   K   | ]  \  }}||f  y wN ).0idxvalues      rJ   	<genexpr>z(Base64Engine.__init__.<locals>.<genexpr>]  s     HzsEuclHs   )r;   r   rB   r<   r   ExpectedStringErrorr=   rU   setbytemap__getitem__	_encode64dict	enumerate	_decode64big_encode_bytes_big_encode_bytes_decode_bytes_big_decode_bytes_encode_bytes_little_decode_bytes_little)selfrs   r   lookups       rJ   __init__zBase64Engine.__init__Q  s    gw'nnY/GGU+))'9==w<2FGGs7|"LMM ,,HYw5GHH++ !%!7!7D!%!7!7D!%!:!:D!%!:!:Dr3   c                 8    | j                   j                  d      S )zcharmap as unicoderr   )r~   decode)r   s    rJ   rs   zBase64Engine.charmaps  s     ||""9--r3   c                 B   t        |t              st        dt        |            t	        t        |      d      \  }}t        rt        t        |            }nt        d |D              }| j                  |||      }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 rR   c              3   2   K   | ]  }t        |        y wrv   )r@   )rx   elems     rJ   r{   z,Base64Engine.encode_bytes.<locals>.<genexpr>  s     #A$CI#As   )r;   r<   rY   typedivmodr=   r   r   iterr   r   r   r   )r   rF   chunkstail
next_valuegenouts          rJ   encode_byteszBase64Engine.encode_bytes{  s     &%(d6lLMMc&k1-#DL1J##A&#AAJ  VT:d4>>378
 
r3   c              #   J  K   d}||k  rN |       } |       } |       }|dz   |dz  dz  |dz	  z   |dz  dz  |dz	  z   |dz	   |dz  }||k  rN|rH |       }|dk(  r|dz   |dz	   y	|dk(  sJ  |       }|dz   |dz  dz  |dz	  z   |dz	   y	y	w)
z>helper used by encode_bytes() to handle little-endian encodingr   ?      rS      rR      r9   Nrw   r   r   r   r   ry   v1v2v3s           rJ   r   z!Base64Engine._encode_bytes_little  s      FlBBBt)OI>BE**I>BE**a%K1HC Fl Bqy4i!eqy \4iT	A~A..!e s   AB#AB#c              #   V  K   d}||k  rN |       } |       } |       }|dz	   |dz  dz  |dz	  z   |dz  dz  |dz	  z   |dz   |dz  }||k  rN|rN |       }|dk(  r|dz	   |dz  dz   y	|dk(  sJ  |       }|dz	   |dz  dz  |dz	  z   |dz  dz   y	y	w)
z;helper used by encode_bytes() to handle big-endian encodingr   rS   rR   r   r   r   r   r9   Nrw   r   s           rJ   r   zBase64Engine._encode_bytes_big  s      FlBBBa%KtGa<"a%((tGa<"a%((t)O1HC Fl Bqy!e$wl"qy \!e4!|b!e,,4!|$ s   AB)AB)c                 p   t        |t              st        dt        |            t	        t        |      d      \  }}|dk(  rt        d      t        t        | j                  |            }	 t        | j                  |||            S # t        $ r }t        d|j                  d         d}~ww xY w)zdecode bytes from base64 string.

        :arg source: byte string to decode.
        :returns: byte string containing decoded data.
        r   r   r9   z(input string length cannot be == 1 mod 4zinvalid character: r   N)r;   r<   rY   r   r   r=   rU   r   r   r   r   r   KeyErrorargs)r   rF   r   r   r   r[   s         rJ   decode_byteszBase64Engine.decode_bytes  s     &%(d6lLMM
 c&k1-19GHHT^^V <=
	G#D$6$6z64$PQQ 	GEFF	Gs   0B 	B5B00B5c              #   2  K   d}||k  rQ |       } |       } |       } |       }||dz  dz  z   |dz	  |dz  dz  z   |dz	  |dz  z   |dz  }||k  rQ|r9 |       } |       }||dz  dz  z   |dk(  r |       }|dz	  |dz  dz  z   yyyw)	z>helper used by decode_bytes() to handle little-endian encodingr   rR   r   rS   r   r   r9   Nrw   	r   r   r   r   ry   r   r   r   v4s	            rJ   r   z!Base64Engine._decode_bytes_little  s      FlBBBBca((q5b3h1_--q5RU##1HC Fl BBca((qy\1u"s(q11     AB<Bc              #   2  K   d}||k  rQ |       } |       } |       } |       }|dz  |dz	  z   |dz  dz  |dz	  z   |dz  dz  |z   |dz  }||k  rQ|r9 |       } |       }|dz  |dz	  z   |dk(  r |       }|dz  dz  |dz	  z   yyyw)	z;helper used by decode_bytes() to handle big-endian encodingr   rS   r   r   rR   r   r9   Nrw   r   s	            rJ   r   zBase64Engine._decode_bytes_big  s      FlBBBBq5RU##sFQ;2q5))sFQ;"$$1HC Fl BBq5RU##qy\3{r1u--  r   c                     t        fdt        | j                        D              }|j                  fdt        | j                        D               t        |      S )z2helper to generate set of valid last chars & bytesc              3   4   K   | ]  \  }}|z  r|  y wrv   rw   rx   icbitss      rJ   r{   z-Base64Engine.__make_padset.<locals>.<genexpr>G  s     H1q4x1H   c              3   4   K   | ]  \  }}|z  r|  y wrv   rw   r   s      rJ   r{   z-Base64Engine.__make_padset.<locals>.<genexpr>H  s     I#!ADAIr   )r}   r   r~   updaters   	frozenset)r   r   psets    ` rJ   __make_padsetzBase64Engine.__make_padsetE  sA    H	$,, 7HHI4<<!8IIr3   c                 J    | j                   rdnd}| | j                  |      fS )zDmask to clear padding bits, and valid last bytes (for strings 2 % 4)r   <   r   _Base64Engine__make_padsetr   r   s     rJ   	_padinfo2zBase64Engine._padinfo2K  s)     XXrEud((...r3   c                 J    | j                   rdnd}| | j                  |      fS )zDmask to clear padding bits, and valid last bytes (for strings 3 % 4)rR   0   r   r   s     rJ   	_padinfo3zBase64Engine._padinfo3R  s)     HHq4ud((...r3   c                    t        |      dz  }|dk(  r| j                  \  }}n&|dk(  r| j                  \  }}n|sd|fS t        d      |d   }||v rd|fS t	        |t
              r.| j                  }||j                  |      |z     }||v sGJ d       | j                  | j                  |      |z        }||v sJ d       t        rt        |g      }d|dd |z   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.
        rR   rS   Fzsource length must != 1 mod 4z%failed to generate valid padding charTN)r=   r   r   rU   r;   r   rs   indexr   r   r   r<   )r   rF   r   maskpadsetlastcms          rJ   check_repair_unusedz Base64Engine.check_repair_unusedY  s     6{Q19>>LD&QY>>LD&&= <== bz6>&=  fg&Bbhhtnt+,D6>J#JJ >>$.."6"=>D6>J#JJdV}VCR[4'''r3   c                 *    | j                  |      d   S )Nr9   )r   r   rF   s     rJ   repair_unusedzBase64Engine.repair_unused  s    ''/22r3   c                     t        t              st        dt                    t	        fd|D              }| j                  |      S )z>encode byte string, first transposing source using offset listr   c              3   (   K   | ]	  }|     y wrv   rw   )rx   rZ   rF   s     rJ   r{   z7Base64Engine.encode_transposed_bytes.<locals>.<genexpr>  s     =cfSk=s   )r;   r<   rY   r   r   r   )r   rF   offsetstmps    `  rJ   encode_transposed_bytesz$Base64Engine.encode_transposed_bytes  s@    &%(d6lLMM=W==  %%r3   c                     | j                  |      }dgt        |      z  }t        ||      D ]
  \  }}|||<    t        |      S )zGdecode byte string, then reverse transposition described by offset listN)r   r=   zipr   )r   rF   r   r   bufrZ   chars          rJ   decode_transposed_bytesz$Base64Engine.decode_transposed_bytes  sR    
 'fs7|#Wc* 	ICCH	s##r3   c                    t        |t              st        dt        |            | j                  }| dz  }||z   dz  }t        |      |k7  rt        d|fz        | j                  }d}	 |r|n
t        |      D ]  }|dz   ||      z   } 	 |r|r||z  }|S |d|z  dz
  z  }|S # t        $ r t        d      w xY w)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: r9   )
r;   r<   rY   r   r   r=   rU   r   reversedr   )	r   rF   r   r   padcharsr   r   r   s	            rJ   _decode_intzBase64Engine._decode_int  s     &%(d6lLMMhheaic1v;%6%ABB	G"V(8 +Av*+  
 4{"
  	G!EFF	Gs   ."B) )Cc                     t        |t              st        dt        |            t	        |      dk7  rt        d      t        r|d   }	 | j                  |      S # t        $ r t        d      w xY w)z(decode single character -> 6 bit integerr   r9   zsource must be exactly 1 byter   invalid character)	r;   r<   rY   r   r=   rU   r   r   r   r   s     rJ   decode_int6zBase64Engine.decode_int6  sq    &%(d6lLMMv;!<==AYF	2>>&)) 	2011	2s   A A3c                 L   t        |t              st        dt        |            t	        |      dk7  rt        d      | j                  }	 | j                  r ||d          ||d         dz  z   S  ||d          ||d         dz  z   S # t        $ r t        d      w xY w)z'decodes 2 char string -> 12-bit integerr   rS   zsource must be exactly 2 bytesr9   r   r   r   	r;   r<   rY   r   r=   rU   r   r   r   r   rF   r   s      rJ   decode_int12zBase64Engine.decode_int12  s    &%(d6lLMMv;!=>>	2xxfQi(F6!9,=q,@AAfQi(F6!9,=q,@AA 	2011	2s   %B 4B B#c                    t        |t              st        dt        |            t	        |      dk7  rt        d      | j                  }	 | j                  r8 ||d          ||d         dz  z    ||d         dz  z    ||d	         d
z  z   S  ||d	          ||d         dz  z    ||d         dz  z    ||d         d
z  z   S # t        $ r t        d      w xY w)z'decodes 4 char string -> 24-bit integerr   r   zsource must be exactly 4 bytesrR   rS   r   r9      r      r   r   r   s      rJ   decode_int24zBase64Engine.decode_int24  s   &%(d6lLMMv;!=>>	2xxfQi(F6!9,=q,@Avay)2-/282CR2GI I fQi(F6!9,=q,@Avay)2-/282CR2GI I 	2011	2s   AC
 7C
 
Cc                 &    | j                  |d      S )&decode 5 char string -> 30 bit integer   r   r   s     rJ   decode_int30zBase64Engine.decode_int30  s    ++r3   c                 &    | j                  |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.
        rt   r   r   s     rJ   decode_int64zBase64Engine.decode_int64  s     ++r3   c                     dk\  sJ d       | dz  }||z  }| j                   rt        |dz
  dd      }|z  nt        d|d      }t        t        | j                  f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   .   K   | ]  }|z	  d z    yw)r   Nrw   )rx   rZ   rz   s     rJ   r{   z+Base64Engine._encode_int.<locals>.<genexpr>"  s      D%*!4 Ds   )r   r   r   r   r   )r   rz   r   r   itrs    `   rJ   _encode_intzBase64Engine._encode_int  s~     z:::eai88aR(CcMED!$CtDNN D D F G 	Gr3   c                 ~    |dk  s|dkD  rt        d      t        r| j                  ||dz    S | j                  |      S )z0encodes 6-bit integer -> single hash64 characterr   r   value out of ranger9   )rU   r   r~   r   r   rz   s     rJ   encode_int6zBase64Engine.encode_int6(  sB    19
122<<eAg..>>%((r3   c                     |dk  s|dkD  rt        d      |dz  |dz	  dz  g}| j                  rt        |      }t        t	        | j
                  |            S )z'encodes 12-bit integer -> 2 char stringr   i  r   r   r   rU   r   r   r   r   r   r   rz   raws      rJ   encode_int12zBase64Engine.encode_int121  sX    19122t|eQh$./883-CtDNNC899r3   c                     |dk  s|dkD  rt        d      |dz  |dz	  dz  |dz	  dz  |dz	  dz  g}| j                  rt        |      }t        t	        | j
                  |            S )z'encodes 24-bit integer -> 4 char stringr   i r   r   r   r   r   r   r   s      rJ   encode_int24zBase64Engine.encode_int24:  sr    19(122t|eQh$.r	T!E2I#57883-CtDNNC899r3   c                 P    |dk  s|dkD  rt        d      | j                  |d      S )r   r   i?r   r   rU   r   r   s     rJ   encode_int30zBase64Engine.encode_int30D  s/    19
*122r**r3   c                 P    |dk  s|dkD  rt        d      | j                  |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   rt   r  r   s     rJ   encode_int64zBase64Engine.encode_int64J  s2     19 22122r**r3   )F)'__name__
__module____qualname____doc__r~   r   r   r   r   r   r   propertyrs   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  rw   r3   rJ   r)   r)      s    >H G
C II MM
;D . .*%N%%VG,!2F!.T / / / /'(R3$&	$"P222",,G4)::++r3   r)   c                   2     e Zd ZdZdZd Z fdZd Z xZS )r*   z<Base64Engine which delays initialization until it's accessedNc                     ||f| _         y rv   )
_lazy_opts)r   r   kwdss      rJ   r   zLazyBase64Engine.__init__\  s    ,r3   c                 d    | j                   \  }}t        t        |   |i | | ` t        | _        y rv   )r  superr*   r   r)   	__class__)r   r   r  r  s      rJ   
_lazy_initzLazyBase64Engine._lazy_init_  s1    __
d.==O%r3   c                 p    |j                  d      s| j                          t        j                  | |      S )N_)
startswithr  object__getattribute__)r   attrs     rJ   r  z!LazyBase64Engine.__getattribute__e  s+    s#OO&&tT22r3   )	r  r  r  r  r  r   r  r  __classcell__)r  s   @rJ   r*   r*   X  s    FJ'&3r3   r*   T)r   rv   )Er  
__future__r   r   r   base64r   r   r   rn   r	   rb   binasciir
   r   r   rX   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#   rC   B_NULLrc   r>   r:   r$   r'   r(   rM   rW   rV   r%   r&   rl   rm   r  r)   r*   r+   r,   r-   rw   r3   rJ   <module>r$     s   A @  E D g!     2J ST ST
 ST ST #QsV+  &'	 &' &' #6#;/ 	
 9:  B2-8 
11&= *#*>? A+$0U	+6 U	+v3| 3, |$	,D	1Ld3r3   