#! / USR / бен / окр питон
# Joric / Bitcoin-DEV, июнь 2012, общественное достояние

импорт hashlib
время импорта
импорт ctypes
импорт ctypes.util
импорт SYS
от pybitcointools импорта *

= ctypes.cdll.LoadLibrary SSL (ctypes.util.find_library ( 'SSL') или 'libeay32')

Защиту check_result (VAL, Func, арг):
    если вал == 0: поднять ValueError
    остальное: возвращение ctypes.c_void_p (вал)

ssl.EC_KEY_new_by_curve_name.restype = ctypes.c_void_p
ssl.EC_KEY_new_by_curve_name.errcheck = check_result

Класс KEY:
    Защиту __init __ (Я):
        NID_secp256k1 = 714
        self.k = ssl.EC_KEY_new_by_curve_name (NID_secp256k1)
        self.compressed = False
        self.POINT_CONVERSION_COMPRESSED = 2
        self.POINT_CONVERSION_UNCOMPRESSED = 4

    Защиту __del __ (Я):
        Если протокол SSL:
            ssl.EC_KEY_free (self.k)
        не self.k = None

    Защита генерация (я, секрет = нет):
        если секрет:
            self.prikey = секрет
            priv_key = ssl.BN_bin2bn (секрет, 32, ssl.BN_new ())
            группа = ssl.EC_KEY_get0_group (self.k)
            pub_key = ssl.EC_POINT_new (группа)
            CTX = ssl.BN_CTX_new ()
            ssl.EC_POINT_mul (группа, pub_key, priv_key, Ничего, Ничего, CTX)
            ssl.EC_KEY_set_private_key (self.k, priv_key)
            ssl.EC_KEY_set_public_key (self.k, pub_key)
            ssl.EC_POINT_free (pub_key)
            ssl.BN_CTX_free (CTX)
            возвращение self.k
        еще:
            вернуться ssl.EC_KEY_generate_key (self.k)

    Защиту get_pubkey (самостоятельно):
        Размер = ssl.i2o_ECPublicKey (self.k, 0)
        Мб = ctypes.create_string_buffer (размер)
        ssl.i2o_ECPublicKey (self.k, ctypes.byref (ctypes.pointer (MB)))
        вернуться mb.raw

    Защиту get_secret (самостоятельно):
        млрд = ssl.EC_KEY_get0_private_key (self.k);
        байт = (ssl.BN_num_bits (Bn) + 7) / 8
        Мб = ctypes.create_string_buffer (байт)
        п = ssl.BN_bn2bin (млрд, Мб);
        вернуть mb.raw.rjust (32, CHR (0))

    Защиту set_compressed (я, компрессией):
        self.compressed = сжатый
        если сжат:
            образуют = self.POINT_CONVERSION_COMPRESSED
        еще:
            образуют = self.POINT_CONVERSION_UNCOMPRESSED
        ssl.EC_KEY_set_conv_form (self.k, форма)

Защита dhash (ы):
    вернуть hashlib.sha256 (hashlib.sha256 (ы) .digest ()). дайджеста ()

Защиту rhash (ы):
    h1 = hashlib.new ( 'ripemd160')
    h1.update (hashlib.sha256 (ы) .digest ())
    вернуться h1.digest ()

b58_digits = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'

Защиту base58_encode (п):
    л = []
    в то время как п > 0:
        п, г = divmod (п, 58)
        l.insert (0, (b58_digits [г]))
    Возвращение '' .join (л)

Защиту base58_decode (ы):
    п = 0
    для ч в с:
        п * = 58
        цифра = b58_digits.index (ч)
        п + = цифра
    вернуться п

Защиту base58_encode_padded (ы):
    разреш = base58_encode (интермедиат ( '0x' + s.encode ( 'шестигранной'), 16))
    подушечка = 0
    для с в е:
        если с == CHR (0):
            коврик + 1 =
        еще:
            ломать
    вернуться b58_digits [0] * коврик + Рез

Защиту base58_decode_padded (ы):
    подушечка = 0
    для с в е:
        если с == b58_digits [0]:
            коврик + 1 =
        еще:
            ломать
    ч = '% х' % base58_decode (ы)
    если Len (ч)% 2:
        ч = '0' + Н
    разреш = h.decode ( 'шестигранной')
    вернуться CHR (0) * коврик + Рез

Защиту base58_check_encode (s, версия = 0):
    Vs = CHR (версия) + S
    проверить = dhash (VS) [: 4]
    возвращение base58_encode_padded (по сравнению с чеком +)

Защиту base58_check_decode (s, версия = 0):
    к = base58_decode_padded (ы)
    v0, данные, check0 = к [0], к [1: -4], к [-4:]
    check1 = dhash (v0 + данные) [: 4]
    если check0 = check1:
        поднять BaseException ( «ошибка контрольной суммы»)
    если версия = Ord (v0):
        поднять BaseException ( «несоответствие версий»)
    возвращать данные

Защиту gen_eckey (ключевая фраза = None, секрет = None, PKey = None, сжато = False, раунды = 1, версия = 0):
    к = КЛЮЧ ()
    если ключевая фраза:
        секрет = passphrase.encode ( 'utf8')
        ибо я в xrange (раундов):
            секрет = hashlib.sha256 (секрет) .digest ()
    если клавишей P.:
        секрет = base58_check_decode (PKey, 128 + версия)
        сжатый = Len (секретный) == 33
        Секрет = секрет [0:32]
    k.generate (секрет)
    k.set_compressed (сжатый)
    возвращение к

Защиту get_addr (к, версия = 0):
    time.sleep (12)
    Публичный = k.get_pubkey ()
    секрет = k.get_secret ()
    hash160 = rhash (Публичный)
    адр = base58_check_encode (hash160, версия)
    Полезная нагрузка = секрет
    если k.compressed:
        Полезная нагрузка = секрет + CHR (1)
    PKey = base58_check_encode (полезная нагрузка, 128 + версия)
    ч = История (адрес)
    если Н = []:
       Распечатать "мы нашли!"
       печать адр
       печать PKey
       sys.exit ()
    вернуться адр, PKEY

Защита Перекодировать (PKey, версия = 0):
    Полезная нагрузка = base58_check_decode (PKey, 128 + версия)
    секрет = полезная нагрузка [: - 1]
    Полезная нагрузка = секрет + CHR (1)
    PKey = base58_check_encode (полезная нагрузка, 128 + версия)
    печать get_addr (gen_eckey (PKey))

Тест четкости (otherversion):
    # Случайным образом сжатый
    #print get_addr (gen_eckey (сжатый = True, версия = otherversion), версия = otherversion)

    # Раскомментируйте их, чтобы создать адреса с помощью другого метода
    # Случайное несжатый
    #print get_addr (gen_eckey ())
    # по секрету
   
    входной_файл = открыт ( 'inputfile.txt', 'г')
    startdata = inputfile.read ()
    inputfile.close ()
    Распечатать "отправная точка"
   
    inputlove = startdata.strip ()   
    inputlove = inputlove.zfill (64)
    inputkeyin = INT (inputlove, 16)

    = INT начальной точки (inputlove, 16)
   

   
    в то время как inputkeyin < + 100 начальную точку:
        печать inputkeyin
        inputkeyhex = гекс (inputkeyin) [2: -1]
        печать inputkeyhex
        get_addr (gen_eckey (секрет = inputkeyhex.decode ( 'шестигранной')))
        inputkeyin = INT (inputkeyhex, 16)
        inputkeyin = inputkeyin + 1
    выходной_файл = открыт ( 'inputfile.txt', 'W')
    outputfile.write (inputkeyhex)
    outputfile.close ()
 
если __name__ == '__main__':
    импорт optparse
    парсер = optparse.OptionParser (использование ="% Проги [опция]")
    parser.add_option ("--otherversion", Приемник ="otherversion", По умолчанию = 0,
                    помощь ="Сформировать адрес с другим номером версии")
    (Опционы, арг) = parser.parse_args ()


answeryes = "Y"
answercapitalyes = "Y"


Распечатать "Y или N - Готов?"
fileresponse = raw_input ()

если fileresponse == answeryes или fileresponse == answercapitalyes:
  тест (интермедиат (options.otherversion))
еще:
  Распечатать "может быть в следующий раз"