ó
ù¢TQc           @  s§  d  Z  d d l m Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l	 m
 Z
 d d l Z y e j ƒ  Z e Z Wn0 e k
 rÂ d d l Z e j d ƒ e Z n Xd d l m Z d d l m Z d d l m Z d d	 l m Z e g  e d
 ƒ D] Z e d A^ qƒ Z e g  e d
 ƒ D] Z e d A^ q<ƒ Z d d „ Z  d d d „ Z! d „  Z" d „  Z# d „  Z$ d „  Z% d d d „ Z& d S(   u3   
Django's standard crypto functions and utilities.
iÿÿÿÿ(   t   unicode_literalsN(   t   reduceuj   A secure pseudo-random number generator is not available on your system. Falling back to Mersenne Twister.(   t   settings(   t   force_bytes(   t   six(   t   xrangei   i\   i6   c         C  s\   | d k r t j } n  t j |  | j d ƒ ƒ j ƒ  } t j | d t	 | ƒ d t j ƒS(   uÖ   
    Returns the HMAC-SHA1 of 'value', using a key generated from key_salt and a
    secret (which defaults to settings.SECRET_KEY).

    A different key_salt should be passed in for every application of HMAC.
    u   utf-8t   msgt	   digestmodN(
   t   NoneR   t
   SECRET_KEYt   hashlibt   sha1t   encodet   digestt   hmact   newR   (   t   key_saltt   valuet   secrett   key(    (    s,   ../Django//lib/python/django/utils/crypto.pyt   salted_hmac#   s    "i   u>   abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789c         C  sy   t  sJ t j t j d t j ƒ  t j ƒ  t j f j	 d ƒ ƒ j
 ƒ  ƒ n  d j g  t |  ƒ D] } t j | ƒ ^ q] ƒ S(   u´   
    Returns a securely generated random string.

    The default length of 12 with the a-z, A-Z, 0-9 character set returns
    a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
    u   %s%s%su   utf-8u    (   t   using_sysrandomt   randomt   seedR
   t   sha256t   getstatet   timeR   R	   R   R   t   joint   ranget   choice(   t   lengtht   allowed_charst   i(    (    s,   ../Django//lib/python/django/utils/crypto.pyt   get_random_string9   s    			#c         C  s¾   t  |  ƒ t  | ƒ k r t Sd } t j rz t |  t ƒ rz t | t ƒ rz xh t |  | ƒ D] \ } } | | | AO} qY Wn: x7 t |  | ƒ D]& \ } } | t | ƒ t | ƒ AO} qŠ W| d k S(   u   
    Returns True if the two strings are equal, False otherwise.

    The time taken is independent of the number of characters that match.
    i    (   t   lent   FalseR   t   PY3t
   isinstancet   bytest   zipt   ord(   t   val1t   val2t   resultt   xt   y(    (    s,   ../Django//lib/python/django/utils/crypto.pyt   constant_time_compareS   s    'c         C  s   t  t j |  ƒ d ƒ S(   uq   
    Convert a binary string into a long integer

    This is a clever optimization for fast xor vector math
    i   (   t   intt   binasciit   hexlify(   R,   (    (    s,   ../Django//lib/python/django/utils/crypto.pyt   _bin_to_longe   s    c         C  s   t  j | |  j d ƒ ƒ S(   uw   
    Convert a long integer into a binary string.
    hex_format_string is like "%020x" for padding 10 characters.
    u   ascii(   R0   t	   unhexlifyR   (   R,   t   hex_format_string(    (    s,   ../Django//lib/python/django/utils/crypto.pyt   _long_to_binn   s    c         C  s¨   | ƒ  | ƒ  } } t  |  ƒ | j k r= | |  ƒ j ƒ  }  n  |  d | j t  |  ƒ 7}  | j |  j t ƒ ƒ | j | ƒ | j |  j t ƒ ƒ | j | j ƒ  ƒ | S(   ug   
    A trimmed down version of Python's HMAC implementation.

    This function operates on bytes.
    t    (   R"   t
   block_sizeR   t   updatet	   translatet	   _trans_36t	   _trans_5c(   R   R   R   t   dig1t   dig2(    (    s,   ../Django//lib/python/django/utils/crypto.pyt
   _fast_hmacv   s    i    c           s  ˆ d k s t  ‚ ˆ s$ t j ‰ n  t ˆ ƒ ‰ t ˆ ƒ ‰ ˆ ƒ  j } | sW | } n  | d | k rv t d ƒ ‚ n  | | } | | d | } d | d ‰  ‡  ‡ ‡ ‡ ‡ f d †  } g  t d | d ƒ D] }	 | |	 ƒ ^ qÑ }
 d j |
 d	  ƒ |
 d	 |  S(   u¾  
    Implements PBKDF2 as defined in RFC 2898, section 5.2

    HMAC+SHA256 is used as the default pseudo random function.

    Right now 10,000 iterations is the recommended default which takes
    100ms on a 2.2Ghz Core 2 Duo.  This is probably the bare minimum
    for security given 1000 iterations was recommended in 2001. This
    code is very well optimized for CPython and is only four times
    slower than openssl's implementation.
    i    i   i    i   u   dklen too bigu   %%0%ixc           s7   ‡  ‡ ‡ ‡ ‡ f d †  } t  t t j | ƒ  ƒ ˆ ƒ S(   Nc          3  sZ   ˆ t  j d ˆ  ƒ }  x= t t ˆ ƒ ƒ D]) } t ˆ |  ˆ ƒ j ƒ  }  t |  ƒ Vq) Wd  S(   Ns   >I(   t   structt   packR   R/   R>   R   R2   (   t   ut   j(   R    t
   iterationst   passwordt   saltR   (    s,   ../Django//lib/python/django/utils/crypto.pyt   U£   s    (   R5   R   t   operatort   xor(   R    RF   (   R4   RC   RD   RE   R   (   R    s,   ../Django//lib/python/django/utils/crypto.pyt   F¢   s    t    iÿÿÿÿI       Iÿÿÿÿ    (   t   AssertionErrorR
   R   R   t   digest_sizet   OverflowErrorR   R   (   RD   RE   RC   t   dklenR   t   hlent   lt   rRI   R,   t   T(    (   R4   RC   RD   RE   R   s,   ../Django//lib/python/django/utils/crypto.pyt   pbkdf2‡   s     	,('   t   __doc__t
   __future__R    R   R?   R
   R0   RG   R   t	   functoolsR   R   t   SystemRandomt   TrueR   t   NotImplementedErrort   warningst   warnR#   t   django.confR   t   django.utils.encodingR   t   django.utilsR   t   django.utils.six.movesR   t	   bytearrayR,   R;   R:   R   R   R!   R.   R2   R5   R>   RS   (    (    (    s,   ../Django//lib/python/django/utils/crypto.pyt   <module>   s<   

))					