#! / USR / бен / питон
# - * - кодирование: ASCII - * -
################################################## #########################
# PBKDF2 - PKCS # 5 v2.0 Password-Based Key Выведение
#
# Copyright (C) 2007-2011 Дуэйн С. Litzenberger 
#
# Разрешать Настоящим предоставляется бесплатно, любому лицу, приобретающему
# Копию этого программного обеспечения и связанных с ними файлов документации (
# "Программного обеспечения"), Чтобы иметь дело в Программное обеспечение без ограничений, в том числе
# Без ограничения права на использование, копирование, изменение, объединение, публикацию,
# Распространять, лицензировать, и / или продавать копии программного обеспечения, и
# Разрешение лица, которым Программное обеспечение поставляется сделать это, при условии
# следующие условия:
#
# Приведенное выше уведомление об авторских правах и данное разрешение должно быть
# Включены во все копии или существенные части Программного обеспечения.
#
# ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ "КАК ЕСТЬ", БЕЗ КАКИХ,
# ЯВНЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ, ГАРАНТИИ
# КОММЕРЧЕСКОЙ ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННОЙ ЦЕЛИ И
# НЕПОСЯГАТЕЛЬСТВА. НИ ПРИ ОБСТОЯТЕЛЬСТВАХ АВТОРЫ ИЛИ ПРАВООБЛАДАТЕЛИ BE
# НЕСЕТ ОТВЕТСТВЕННОСТИ ЗА ЛЮБЫЕ ПРЕТЕНЗИИ, УБЫТКИ ИЛИ ДРУГИХ ОТВЕТСТВЕННОСТИ, В РЕЗУЛЬТАТЕ
# Договора, ДЕЛИКТА ИЛИ ИНАЧЕ, ВОЗНИКАЮЩИЕ ИЗ, ИЛИ В СВЯЗИ
# С SOFTWARE ИЛИ ИСПОЛЬЗОВАНИЕМ ИЛИ ИНЫМИ ДЕЙСТВИЯМИ В ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ.
#
# Страна происхождения: Канада
#
################################################## #########################
# Пример PBKDF2 использование:
# От Crypto.Cipher импорта AES
# От PBKDF2 импорта PBKDF2
# Импорт ОС
#
# Соль = os.urandom (8) # 64-битная соль
# Ключ = PBKDF2 ("Это ключевая фраза является секретом.", Соль) .read (32) # 256-битный ключ
# IV = os.urandom (16) # 128-битный И.В.
# Шифра = AES.new (ключ, AES.MODE_CBC, внутривенно)
# ...
#
# Пример склепа () использование:
# Из PBKDF2 импорта склепа
# Pwhash = крипты ("секрет")
# Alleged_pw = raw_input ("Введите пароль: ")
# Если pwhash == крипты (alleged_pw, pwhash):
#       Распечатать "Пароль хорошо"
# Еще:
#       Распечатать "Неверный пароль"
#
################################################## #########################

__version__ = "0,1"
__all__ = [ 'PBKDF2_RMD', 'крипты']

от структуры импорта пакета
от случайного импорта randint
импорт строка
импорт SYS

пытаться:
    # Используйте PyCrypto (если таковые имеются).
    от Crypto.Hash импорта HMAC, SHA как SHA1, RIPEMD как RMD
кроме ImportError:
    Распечатать "Ошибка импорта: PyCrypto не установлен!"
    Выход (0)
    # PyCrypto не доступно. Используйте стандартную библиотеку Python.
# Импорт HMAC, как HMAC
#    пытаться:
# От hashlib импорта sha1 как SHA1
# Кроме ImportError:
        # Hashlib не доступно. Используйте старый модуль ша.
# Импорт ша, как SHA1

#
# Python 2.1 через 3.2 совместимость
#

если sys.version_info [0] == 2:
    _0xffffffffL = длинный (1) << 32
    Защиту isunicode (ы):
        Возвращение isinstance (с, Unicode)
    Защиту isbytes (ы):
        Возвращение isinstance (с, ул)
    Защиту isinteger (п):
        Возвращение isinstance (п, (интермедиат, долго))
    Защиту б (ы):
        возвращение s
    Защиту binxor (а, б):
        вернуть "".join ([CHR (ORD (х) ^ Ord (у)) для (х, у) в почтовый индекс (а, б)])
    Защиту b64encode (данные, си ="+ /"):
        TT = string.maketrans ("+ /", Символы)
        вернуться data.encode ( 'base64'). заменить ("\ п", "") .translate (тт)
    от binascii импорта b2a_hex
еще:
    _0xffffffffL = 0xffffffff
    Защиту isunicode (ы):
        Возвращение isinstance (с, ул)
    Защиту isbytes (ы):
        Возвращение isinstance (s, байт)
    Защиту isinteger (п):
        Возвращение isinstance (п целое)
    Защиту отозваны (объект):
        вернуть hasattr (объект, '__call__')
    Защиту б (ы):
       вернуться s.encode ("латино-1")
    Защиту binxor (а, б):
        вернуть байты ([х ^ у для (х, у) в почтовый индекс (а, б)])
    из base64 импорта b64encode как _b64encode
    Защиту b64encode (данные, си ="+ /"):
        если isunicode (символы):
            Возвращение _b64encode (данные, chars.encode ( 'UTF-8')). декодировать ( 'UTF-8')
        еще:
            Возвращение _b64encode (данные, символы)
    от binascii импорта b2a_hex как _b2a_hex
    Защиту b2a_hex (ы):
        вернуться _b2a_hex (s) .decode ( 'US-ASCII')
    xrange = диапазон

Класс PBKDF2_RMD (объект):
    """PBKDF2.py: PKCS # 5 v2.0 Password-Based Key Выведение

    Эта реализация занимает ключевую фразу и соль (и необязательно
    счетчик цикла, модуль дайджеста и модуль MAC), и обеспечивает
    файл-подобный объект, из которого ключ произвольно размера может быть прочитан.

    Если ключевая фраза и / или соли являются Юникодом объектов, они кодируются как
    UTF-8, прежде чем они будут обработаны.

    Идея PBKDF2 заключается в получении криптографического ключа от
    ключевая фраза и соль.

    PBKDF2 также может быть использован в качестве сильного соленого хэша пароля.
    «Крипта» функция предусмотрена для этой цели.

    Помните: ключи, сгенерированные с помощью PBKDF2 только так сильны, как
    ключевые фразы они получены из.
    """

    Защиту __init __ (самоповреждения, PassPhrase, соль, итераций = 1000,
                 digestmodule = ДУЗ, macmodule = HMAC):
        само .__ macmodule = macmodule
        само .__ digestmodule = digestmodule
        self._setup (ключевая фраза, соль, Итерация, self._pseudorandom)

    Защиту _pseudorandom (я, ключ, сбщ):
        """Псевдослучайной функции. например HMAC-SHA1"""
        Самовозврат .__ macmodule.new (ключ = ключ, сообщ = тзд,
            digestmod = само .__ digestmodule) .digest ()

    Защита чтения (я, байты):
        """Прочитайте заданное число байтов ключа."""
        если self.closed:
            поднять ValueError ("файл-подобный объект закрыт")

        Размер = Len (само .__ ЬиЕ)
        блоки = [само .__ ЬиЕ]
        я = само .__ blockNum
        в то время как размер < байт:
            I + 1 =
            Если я > _0xffffffffL или я < 1:
                # Мы могли бы вернуться "" здесь, но
                поднять OverflowError ("выведенный ключ слишком долго")
            Блок = Автономный .__ F (я)
            blocks.append (блок)
            площадь + = Len (блок)
        ЬиЕ = B ("") .join (блоки)
        RetVal = ЬиЕ [: байт]
        само .__ ЬиЙ = ЬиЙ [байты:]
        само .__ blockNum = я
        возвращение RetVal

    Защиту __f (я, я):
        # Я должен вписываться в 32 бит
        утверждать 1 <= я <= _0xffffffffL
        U = само .__ ч.р.ф. (само .__ ключевой фразы, само .__ соли + упаковка ("! L", Я))
        Результат = U
        для J в xrange (2, 1 + я) .__ итераций:
            U = само .__ ч.р.ф. (само .__ ключевой фразы, U)
            Результат = binxor (результат, U)
        возвращаемый результат

    Защиту hexread (самость, октет):
        """Прочитайте заданное число октетов. Верните их в шестнадцатеричном формате.

        Обратите внимание, что Len (obj.hexread (п)) == 2 * N.
        """
        вернуться b2a_hex (self.read (октетов))

    Защиту _setup (самость, ключевая фраза, соль, Итерация, PRF):
        # Sanity проверки:

        # Ключевая фраза и соль должны быть Обл или юникода (в последнем
        # Случай, мы преобразуем в UTF-8)
        если isunicode (ключевая фраза):
            ключевая фраза = passphrase.encode ("UTF-8,")
        Элиф не isbytes (фраза):
            поднять TypeError ("ключевая фраза должна быть Обл или юникода")
        если isunicode (соль):
            соль = salt.encode ("UTF-8,")
        ELIF не isbytes (соль):
            поднять TypeError ("соль должны быть ул или Юникода")

        # итерации должны быть целым числом >= 1
        если не isinteger (итераций):
            поднять TypeError ("Итерации должны быть целым числом")
        если итераций < 1:
            поднять ValueError ("Итерации должны быть по крайней мере 1")

        # Ч.р.ф. должны быть отозваны
        если не отозван (PRF):
            поднять TypeError ("ч.р.ф. должен быть отозван")

        самостоятельно .__ ключевая фраза = ключевая фраза
        Селф .__ соль = соль
        само .__ итерации = итерации
        само .__ ч.р.ф. = ч.р.ф.
        самостоятельно .__ blockNum = 0
        самостоятельно .__ BUF = B ("")
        self.closed = False

    Защита близко (Я):
        """Закройте поток."""
        если не self.closed:
            дель самостоятельная .__ ключевой фразы
            дель Селф .__ соль
            дель самоуправления .__ Итерации
            дель самоуправления .__ ч.р.ф.
            дель самоуправления .__ blockNum
            дель самоуправления .__ ЬиЕ
            self.closed = True

Защита склеп (слово, соль = None, Итерации = None):
    """PBKDF2 на основе Unix крипта (3) замены.

    Число итераций, указанных в соли перекрывает «» итераций
    параметр.

    Эффективная длина хэша составляет 192 бит.
    """

    # Генерация (псевдо-) случайная соль, если пользователь не предоставил.
    если соль не None:
        соль = _makesalt ()

    # Соль должна быть строка или US-ASCII подмножество Юникода
    если isunicode (соль):
        соль = salt.encode ( 'US-ASCII'). декодировать ( 'US-ASCII')
    Элиф isbytes (соль):
        соль = salt.decode ( 'US-ASCII')
    еще:
        поднять TypeError ("соль должна быть строка")

    # Слово должно быть строкой или юникода (в последнем случае, мы преобразуем в UTF-8)
    если isunicode (слово):
        слово = word.encode ("UTF-8,")
    Элиф не isbytes (слово):
        поднять TypeError ("Слово должно быть строкой или юникода")

    # Попробуйте извлечь реальную соль и итерационное количество из соли
    если salt.startswith ("$ P5k2 $"):
        (Итерации, соль, фиктивные) = salt.split ("$") [2: 5]
        если итерации == "":
            Итерации = 400
        еще:
            Преобразованные = INT (итерации, 16)
            если итерации! = "%Икс" % Конвертировано: # строчных шестигранные, минимальные цифры
                поднять ValueError ("Invalid соль")
            Итерации = конвертированы
            если нет (итераций >= 1):
                поднять ValueError ("Invalid соль")

    # Убедитесь, что соль соответствует разрешенному набору символов
    разрешено = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./"
    для ч в соли:
        если ч не допускается:
            поднять ValueError ("Недопустимый символ% г соли" % (Ч))

    если итерации None или итерация == 400:
        Итерации = 400
        соль = "$ P5k2 $$" + соль
    еще:
        соль = "$ P5k2 $% х $% s" % (Итерации, соль)
    rawhash = PBKDF2_RMD (слово, соль, Итерация) .read (24)
    обратная соль + "$" + B64encode (rawhash, "./")

# Добавить крипту как статический метод класса PBKDF2
# Это делает его легче сделать "от PBKDF2 импорта PBKDF2" и до сих пор используют
# Крипты.
PBKDF2_RMD.crypt = STATICMETHOD (крипты)

Защиту _makesalt ():
    """Возвращение 48-битную псевдослучайную соли в течение крипты ().

    Эта функция не подходит для генерации криптографических секретов.
    """
    binarysalt = Ь ("") .join ([упаковка ("@ЧАС", Randint (0, 0xFFFF)) для г в диапазоне (3)])
    вернуться b64encode (binarysalt, "./")

# ВИМ: установить TS = 4 SW = 4 петли = 4 expandtab:
#