コード例 #1
0
    def _calculate_hash(self, filename, **kwargs):
        """
        Calculates the hash of the file and the hash of the file + metadata
        (passed in ``kwargs``).

        Args:
            filename (str): Name of the file
            testnet (bool): testnet flag. Defaults to False
            **kwargs: Additional metadata to be encoded with the file. Only
                the values are used to compute the hash. Values are
                ordered using their keys, so that the computation of the
                hash is consistent. As an example, given::

                    File('filename', title='piece title', artist='artist')

                the values ``('artist', 'piece title')`` would be used in that
                order for the computation of the hash.

        """
        with open(filename, 'rb') as f:
            file_hash = hashlib.md5(f.read()).hexdigest()

        if kwargs:
            data = str(
                [urepr(kwargs[k]) for k in sorted(kwargs)] + [file_hash])
        else:
            data = file_hash

        address_piece_with_metadata = str(
            bin_to_b58check(bin_hash160(data.encode()),
                            magicbyte=self._magicbyte)
        )
        address_piece = str(bin_to_b58check(bin_hash160(file_hash.encode()),
                                            magicbyte=self._magicbyte))
        return address_piece, address_piece_with_metadata
コード例 #2
0
ファイル: test_keys.py プロジェクト: AdamISZ/joinmarket
def test_wif_privkeys_invalid(setup_keys):
    #first try to create wif privkey from key of wrong length
    bad_privs = ['\x01\x02'*17] #some silly private key but > 33 bytes

    #next try to create wif with correct length but wrong compression byte
    bad_privs.append('\x07'*32 + '\x02')
    
    for priv in bad_privs:
        with pytest.raises(Exception) as e_info:
            fake_wif = btc.wif_compressed_privkey(binascii.hexlify(priv))

    #Create a wif with wrong length
    bad_wif1 = btc.bin_to_b58check('\x01\x02'*34, 128)
    #Create a wif with wrong compression byte
    bad_wif2 = btc.bin_to_b58check('\x07'*33, 128)
    for bw in [bad_wif1, bad_wif2]:
        with pytest.raises(Exception) as e_info:
            fake_priv = btc.from_wif_privkey(bw)

    #Some invalid b58 from bitcoin repo;
    #none of these are valid as any kind of key or address
    with open("test/base58_keys_invalid.json", "r") as f:
        json_data = f.read()
    invalid_key_list = json.loads(json_data)
    for k in invalid_key_list:
        bad_key = k[0]
        for netval in ["mainnet", "testnet"]:
            jm_single().config.set("BLOCKCHAIN", "network", netval)
            #if using py.test -s ; sanity check to see what's actually being tested
            print 'testing this key: ' + bad_key
            if "decode_privkey" in dir(btc):
                try:
                    bad_key_format = btc.get_privkey_format(bad_key)
                    print 'has correct format: ' + bad_key_format
                except:
                    pass
            #should throw exception
            with pytest.raises(Exception) as e_info:
                if "decode_privkey" in dir(btc):
                    from_wif_key = btc.decode_privkey(bad_key)
                else:
                    from_wif_key = btc.from_wif_compressed_privkey(
                        bad_key, btc.get_version_byte(bad_key))
                #in case the b58 check encoding is valid, we should
                #also check if the leading version byte is in the
                #expected set, and throw an error if not.
                if chr(btc.get_version_byte(bad_key)) not in '\x80\xef':
                    raise Exception("Invalid version byte")
                #the bitcoin library should throw
                #if the compression byte is not there (test not needed
                #for secp256k1 branch since the wif_compressed function checks)
                if "decode_privkey" in dir(btc):
                    if "compressed" in btc.get_privkey_format(bad_key) and \
                   btc.b58check_to_bin(x)[-1] != '\x01':
                        raise Exception("Invalid compression byte")
コード例 #3
0
def test_wif_privkeys_invalid(setup_keys):
    #first try to create wif privkey from key of wrong length
    bad_privs = ['\x01\x02' * 17]  #some silly private key but > 33 bytes

    #next try to create wif with correct length but wrong compression byte
    bad_privs.append('\x07' * 32 + '\x02')

    for priv in bad_privs:
        with pytest.raises(Exception) as e_info:
            fake_wif = btc.wif_compressed_privkey(binascii.hexlify(priv))

    #Create a wif with wrong length
    bad_wif1 = btc.bin_to_b58check('\x01\x02' * 34, 128)
    #Create a wif with wrong compression byte
    bad_wif2 = btc.bin_to_b58check('\x07' * 33, 128)
    for bw in [bad_wif1, bad_wif2]:
        with pytest.raises(Exception) as e_info:
            fake_priv = btc.from_wif_privkey(bw)

    #Some invalid b58 from bitcoin repo;
    #none of these are valid as any kind of key or address
    with open("test/base58_keys_invalid.json", "r") as f:
        json_data = f.read()
    invalid_key_list = json.loads(json_data)
    for k in invalid_key_list:
        bad_key = k[0]
        for netval in ["mainnet", "testnet"]:
            jm_single().config.set("BLOCKCHAIN", "network", netval)
            #if using py.test -s ; sanity check to see what's actually being tested
            print 'testing this key: ' + bad_key
            if "decode_privkey" in dir(btc):
                try:
                    bad_key_format = btc.get_privkey_format(bad_key)
                    print 'has correct format: ' + bad_key_format
                except:
                    pass
            #should throw exception
            with pytest.raises(Exception) as e_info:
                if "decode_privkey" in dir(btc):
                    from_wif_key = btc.decode_privkey(bad_key)
                else:
                    from_wif_key = btc.from_wif_compressed_privkey(
                        bad_key, btc.get_version_byte(bad_key))
                #in case the b58 check encoding is valid, we should
                #also check if the leading version byte is in the
                #expected set, and throw an error if not.
                if chr(btc.get_version_byte(bad_key)) not in '\x80\xef':
                    raise Exception("Invalid version byte")
                #the bitcoin library should throw
                #if the compression byte is not there (test not needed
                #for secp256k1 branch since the wif_compressed function checks)
                if "decode_privkey" in dir(btc):
                    if "compressed" in btc.get_privkey_format(bad_key) and \
                   btc.b58check_to_bin(x)[-1] != '\x01':
                        raise Exception("Invalid compression byte")
コード例 #4
0
def pubkey_to_address(pubKey: str, magic_byte = 0) -> str:
  pubKeyBytes = binascii.unhexlify(pubKey)
  sha256val = hashlib.sha256(pubKeyBytes).digest()
  ripemd160val = hashlib.new('ripemd160', sha256val).digest()
  print (binascii.hexlify(sha256val))
  print (binascii.hexlify(ripemd160val))
  print (magic_byte)
  return bitcoin.bin_to_b58check(ripemd160val, magic_byte)
コード例 #5
0
def script_to_address(script, vbyte=0):
    '''
    Like script_to_address but supports altcoins
    Copied 2015-10-02 from https://github.com/mflaxman/pybitcointools/blob/faf56c53148989ea390238c3c4541a6ae1d601f5/bitcoin/transaction.py#L224-L236
    '''
    if re.match('^[0-9a-fA-F]*$', script):
        script = binascii.unhexlify(script)
    if script[:3] == b'\x76\xa9\x14' and script[-2:] == b'\x88\xac' and len(script) == 25:
        return bin_to_b58check(script[3:-2], vbyte)  # pubkey hash addresses
    else:
        if vbyte in [111, 196]:
            # Testnet
            scripthash_byte = 196
        else:
            scripthash_byte = vbyte
        # BIP0016 scripthash addresses
        return bin_to_b58check(script[2:-1], scripthash_byte)
コード例 #6
0
def pubkey2adr(pub_hex, network=5):
    pub_bin = bitcoin.encode_pubkey(pub_hex, "bin_compressed")
    PKH = bitcoin.bin_hash160(pub_bin)
    # script = "\0" + PKH
    # address_bin = bitcoin.bin_hash160(script)
    address = bitcoin.bin_to_b58check(PKH, 0)
    #assert bitcoin.p2sh_scriptaddr(script,network) == address
    return address
コード例 #7
0
def get_keys(mnemonic, email, password):
    salt = unicodedata.normalize(
        "NFKD", (email + password).decode("utf8")).encode("utf8")
    seed = bitcoin.mnemonic_to_seed(mnemonic, salt)
    pk, sk = pysodium.crypto_sign_seed_keypair(seed[0:32])
    pkh = blake2b(pk, 20).digest()
    pkhb58 = bitcoin.bin_to_b58check(pkh, magicbyte=434591)
    return (sk, pk, pkh, pkhb58)
コード例 #8
0
ファイル: file.py プロジェクト: sbellem/pyspool
    def _calculate_hash(self, filename, **kwargs):
        """
        Calculates the hash of the file and the hash of the file + metadata (passed on the keywargs)
        """

        # hash to address
        with open(filename, 'rb') as f:
            file_hash = hashlib.md5(f.read()).hexdigest()

        if kwargs:
            data = str([unicode(value) for value in kwargs.itervalues()] + [file_hash])
        else:
            data = file_hash
        address_piece_with_metadata = unicode(bitcoin.bin_to_b58check(bitcoin.bin_hash160(data),
                                                                             magicbyte=self._magicbyte))
        address_piece = unicode(bitcoin.bin_to_b58check(bitcoin.bin_hash160(file_hash),
                                                               magicbyte=self._magicbyte))
        return address_piece, address_piece_with_metadata
コード例 #9
0
def pkvkey2adrw(pvkey, network=5):
    pub_hex = bitcoin.privtopub(pvkey)
    pub_bin = bitcoin.encode_pubkey(pub_hex, "bin_compressed")
    PKH = bitcoin.bin_hash160(pub_bin)
    script = "\0\x14" + PKH
    address_bin = bitcoin.bin_hash160(script)
    address = bitcoin.bin_to_b58check(address_bin, network)
    assert bitcoin.p2sh_scriptaddr(script, network) == address
    return address
コード例 #10
0
ファイル: crypto.py プロジェクト: Blockwala/wallet-backend
def script_to_address(script, vbyte=0):
    '''
    Like script_to_address but supports altcoins
    Copied 2015-10-02 from https://github.com/mflaxman/pybitcointools/blob/faf56c53148989ea390238c3c4541a6ae1d601f5/bitcoin/transaction.py#L224-L236
    '''
    if re.match('^[0-9a-fA-F]*$', script):
        script = binascii.unhexlify(script)
    if script[:3] == b'\x76\xa9\x14' and script[-2:] == b'\x88\xac' and len(
            script) == 25:
        return bin_to_b58check(script[3:-2], vbyte)  # pubkey hash addresses
    else:
        if vbyte in [111, 196]:
            # Testnet
            scripthash_byte = 196
        else:
            scripthash_byte = vbyte
        # BIP0016 scripthash addresses
        return bin_to_b58check(script[2:-1], scripthash_byte)
コード例 #11
0
def genesis_commitments(wallets, blind):
    commitments = []
    for pkh_b58, amount in wallets.iteritems():
        # Public key hash corresponding to this Tezos address.
        pkh = bitcoin.b58check_to_bin(pkh_b58)[2:]
        hpkh_b58 = bitcoin.bin_to_b58check((pkh[:10] + '\000' * 10), magicbyte=434591)
        # The redemption code is unique to the public key hash and deterministically
        # constructed using a secret blinding value.
        secret = secret_code(pkh, blind)
        # The redemption code is used to blind the pkh
        blinded_pkh = blake2b(pkh, 20, key=secret).digest()
        commitment = {
            'half_pkh': hpkh_b58,
            'blinded_pkh': bitcoin.bin_to_b58check(blinded_pkh, magicbyte=16921055),
            'amount': amount
        }
        commitments.append(commitment)
    return commitments
コード例 #12
0
def make_dummy_wallets(n, blind):
    # Not a realistic shape, but for an alphanet faucet it's better to
    # have less variance.
    amounts = np.random.pareto(10.0, n)
    amounts = amounts / sum(amounts) * 760e6
    wallets = {}
    secret_seeds = {}
    for i in range(0, n):
        seed = blake2b(str(i), 32, key=blind).digest()
        pk, sk = pysodium.crypto_sign_seed_keypair(seed)
        pkh = blake2b(pk, 20).digest()
        pkh_b58 = bitcoin.bin_to_b58check(pkh, magicbyte=434591)
        amount = tez_to_int(amounts[i])
        wallets[pkh_b58] = amount
        secret = secret_code(pkh, blind)
        secret_seeds[pkh_b58] = (bitcoin.bin_to_b58check(seed,
                                                         magicbyte=219101703),
                                 amount, binascii.hexlify(secret))
    return wallets, secret_seeds
コード例 #13
0
ファイル: bitcoin_like.py プロジェクト: rkanadev/CryptoWallet
 def create_pair(b58_magic_byte, address_magic_byte, seed=None):
     """Function create private key and address"""
     if seed is None:
         seed = KeyGenerator.random_seed()
     hash = sha256(seed)
     private_key = int(hash, base=16)
     private_key_wif = bin_to_b58check(encode(private_key, 256, 32),
                                       b58_magic_byte)
     address = privkey_to_address(private_key, address_magic_byte)
     return private_key_wif, address
コード例 #14
0
def gen_address_for_data(data):
    print("Hashing data: " + str(data))

    # https://gist.github.com/patricklodder/b27fb3e91c0566272976#file-gistfile1-py-L390
    # RIPEMD160(SHA256(data))
    fingerprint = bin_hash160(data.encode())
    print("Data fingerprint: " + str(fingerprint.encode('hex')))

    address = str(bin_to_b58check(fingerprint), magicbyte=_magicbyte)
    print("Final address: " + str(address))

    return address
コード例 #15
0
def gen_address_for_data(data):
	print("Hashing data: "+str(data))

	# https://gist.github.com/patricklodder/b27fb3e91c0566272976#file-gistfile1-py-L390
	# RIPEMD160(SHA256(data))
	fingerprint = bin_hash160(data.encode())
	print("Data fingerprint: "+str(fingerprint.encode('hex')))

	address = str(bin_to_b58check(fingerprint), magicbyte=_magicbyte)
	print("Final address: "+str(address))

	return address
コード例 #16
0
    def __init__(self, hexdata):
        if not all(c in string.hexdigits for c in hexdata):
            raise('Invalid signature request: not all hex digits')

        self.payload = hexdata
        data = bytes.fromhex(hexdata)

        self.chainid = bitcoin.bin_to_b58check(data[1:5], magicbyte=CHAIN_ID)

        if data[0] == 0x01:     # Emmy block
            self.type  = "Baking"
            self.level = get_be_int(data[5:])
            self.round = 0

        elif data[0] == 0x02:   # Emmy endorsement
            self.type  = "Endorsement"
            self.level = get_be_int(data[-4:])
            self.round = 0

        elif data[0] == 0x11:   # Tenderbake block
            self.type  = "Baking"
            self.level = get_be_int(data[5:])
            fitness_sz = get_be_int(data[83:])
            offset = 87 + fitness_sz - 4
            self.round = get_be_int(data[offset:])

        elif data[0] == 0x12:   # Tenderbake preendorsement
            self.type  = "Preendorsement"
            self.level = get_be_int(data[40:])
            self.round = get_be_int(data[44:])

        elif data[0] == 0x13:   # Tenderbake endorsement
            self.type  = "Endorsement"
            self.level = get_be_int(data[40:])
            self.round = get_be_int(data[44:])

        else:
            self.type = "Unknown operation"

        self.logstr = f"{self.chainid} {self.type}"
        if self.level != None:
            self.logstr += f" at {self.level}/{self.round}"
コード例 #17
0
def check(password, email, mnemonic, address, iters=2048):

    salt = unicodedata.normalize("NFKD", (email + password)).encode("utf8")
    seed = pbkdf2_hmac(hash_name='sha512',
                       password=mnemonic,
                       salt=b"mnemonic" + salt,
                       iterations=iters)
    pk, sk = pysodium.crypto_sign_seed_keypair(seed[0:32])
    pkh = blake2b(pk, 20).digest()
    decrypted_address = bitcoin.bin_to_b58check(pkh, magicbyte=434591)

    if address == decrypted_address:
        found_it = "True"
        print("found it ")
        print("Your password is: ", password)
        with open("password.lst", 'a') as z:
            z.write((password) + '\n')
            z.close()

    else:
        found_it = "False"
    return (found_it, password)
コード例 #18
0
ファイル: keygen.py プロジェクト: tezos/fundraiser-tools
import unicodedata
import sys
import bitcoin
import pysodium
from pyblake2 import blake2b
from hashlib import sha256
import binascii

if __name__ == '__main__':
    mnemonic = ' '.join(
        bitcoin.mnemonic.entropy_to_words(pysodium.randombytes(32)))
    seed = bitcoin.mnemonic_to_seed(mnemonic)[:32]
    pk, sk = pysodium.crypto_sign_seed_keypair(seed)
    pkh = bitcoin.bin_to_b58check(blake2b(pk, 20).digest(), magicbyte=434591)
    secret_key = bitcoin.bin_to_b58check(seed, magicbyte=219101703)
    print "mnemonic: %s" % mnemonic
    print "secret seed: %s" % secret_key
    print "public key hash: %s" % pkh
コード例 #19
0
def tezos_pkh(digest):
    return bitcoin.bin_to_b58check(digest, magicbyte=434591)
コード例 #20
0
        password = sys.argv[17]
        salt = unicodedata.normalize(
            "NFKD", (email + password).decode("utf8")).encode("utf8")
        try:
            seed = bitcoin.mnemonic_to_seed(mnemonic, salt)
        except:
            print("Invalid mnemonic")
            exit(1)
        pk, sk = pysodium.crypto_sign_seed_keypair(seed[0:32])
        pkh = blake2b(pk, 20).digest()

        print "public key hash: ", tezos_pkh(pkh)

    elif len(sys.argv) == 2:
        tz_input = sys.argv[1]
        assert (tz_input == bitcoin.bin_to_b58check(
            bitcoin.b58check_to_bin(tz_input)[2:], magicbyte=434591))

        try:
            pkh = bitcoin.b58check_to_bin(tz_input)[2:]
        except:
            print "Invalid public key hash"

    else:
        print("""Usage:
python keychecker.py garage absurd steak ...  email password
or
python keychecker.py tz1YoUrPuBlicKeYhaSh""")
        exit(1)

    print "Ethereum data:   ", ethereum_data(pkh)
    print "Bitcoin address: ", bitcoin_address(pkh)
コード例 #21
0
def tezos_pkh(pkh):
    return bitcoin.bin_to_b58check(pkh.digest(), magicbyte=434591)
コード例 #22
0
def asciidec(val):
    word = []
    while val > 0:
        word.append(val % 256)
        val /= 256
    return word[-1::-1]


if __name__ == '__main__':

    prefix = sys.argv[1]
    length = int(sys.argv[2])
    target = b58dec(prefix)

    shift = 8 * (length + 4)

    for m in range(1, 1000):
        lo = target * 58**m
        lo = (lo >> shift) + (0 if lo == ((lo >> shift) << shift) else 1)
        hi = (target + 1) * 58**m - (1 << shift) + 1
        hi = hi >> shift
        if hi >= lo:
            # test
            for bt in '\x00\xff':
                s = bitcoin.bin_to_b58check(bt * length, magicbyte=lo)
                assert s.startswith(prefix)
                assert len(s) == m + len(prefix)

            print m + len(prefix), lo, asciidec(lo)
            exit(0)
コード例 #23
0
 def b58encode_signature(sig):
     return bitcoin.bin_to_b58check(sig,
                                    magicbyte=RemoteSigner.P256_SIGNATURE)
def public_key_to_address(publicKey: str, magic_byte=0) -> str:
    publicKeyBytes = binascii.unhexlify(publicKey)
    sha256hash = hashlib.sha256(publicKeyBytes).digest()
    ripemd160hash = hashlib.new('ripemd160', sha256hash).digest()
    return bitcoin.bin_to_b58check(ripemd160hash, magic_byte)
コード例 #25
0
 def get_chain_id(self):
     chainid = bytes.fromhex(self.payload[2:10])
     return bitcoin.bin_to_b58check(chainid,
                                    magicbyte=RemoteSigner.CHAIN_ID)
コード例 #26
0
import bitcoin

from src.sigreq import SignatureReq
from src.validatesigner import ValidateSigner
from src.signer import Signer
from src.chainratchet import MockChainRatchet


def eatwhite(str):
    return re.sub(r"\s+", "", str)

# results in p2sig prefix when encoded with base58 (p2sig(98)):
P256_SIG= struct.unpack('>L', b'\x36\xF0\x2C\x34')[0]
RAW_SIGNED_BLOCK = b'0123456789012345678901'
SIGNED_BLOCK = bitcoin.bin_to_b58check(RAW_SIGNED_BLOCK, magicbyte=P256_SIG)

#
# Here's a quick invalid block that we'll make sure that we don't process:

INVALID_PREAMBLE = eatwhite("""
        030000000000000002012c866bd675ad11475ea608dea4d9d166801f1725b2076363
        63d55508aa07ba6f000000005b17b90d04683625c2445a4e9564bf710c5528fd99a7
        d150d2a2a323bc22ff9e2710da4f6d00000011000000010000000008000000000000
        000289b5a4e5e20c56512c64967dfa72e67c39166d5c48ad6884693c7d192e105c3b
        00058f7b73557941607800""")

#
# Here we provide a list of valid blocks over which we shall iterate:
# They are each a tuple of the expected results:
#         (type, chainid, level, round)
コード例 #27
0
def load_wallet(wallet_file, get_password_fn):
    """load and if necessary decrypt a bitcoinj wallet file

    :param wallet_file: an open bitcoinj wallet file
    :type wallet_file: file
    :param get_password_fn: a callback returning a password that's called iff one is required
    :type get_password_fn: function
    :return: the Wallet protobuf message or None if no password was entered when required
    :rtype: wallet_pb2.Wallet
    """

    wallet_file.seek(0)
    magic_bytes = wallet_file.read(12)
    
    wallet_file.seek(0, os.SEEK_END)
    wallet_size = wallet_file.tell()
    wallet_file.seek(0)

    if magic_bytes[2:6] != b"org." and wallet_size % 16 == 0:
        import pylibscrypt
        takes_long = not pylibscrypt._done  # if a binary library wasn't found, this'll take a while

        ciphertext = wallet_file.read()
        assert len(ciphertext) % 16 == 0

        password = get_password_fn(takes_long)
        if not password:
            return None

        # Derive the encryption key
        salt = '\x35\x51\x03\x80\x75\xa3\xb0\xc5'
        key  = pylibscrypt.scrypt(password.encode('utf_16_be'), salt, olen=32)

        # Decrypt the wallet ( v0.5.0+ )
        try:
            plaintext = aes256_cbc_decrypt(ciphertext[16:], key, ciphertext[:16])
            if plaintext[2:6] != b"org.":
                raise ValueError('incorrect password')
        except ValueError as e:
            if e.args[0] == 'incorrect password':

                # Decrypt the wallet ( < v0.5.0 )
                iv = '\xa3\x44\x39\x1f\x53\x83\x11\xb3\x29\x54\x86\x16\xc4\x89\x72\x3e'
                plaintext = aes256_cbc_decrypt(ciphertext, key, iv)

        global multibit_hd_password
        multibit_hd_password = password

    # Else it's not whole-file encrypted
    else:
        password  = None
        plaintext = wallet_file.read()

    # Parse the wallet protobuf
    pb_wallet = wallet_pb2.Wallet()
    try:
        pb_wallet.ParseFromString(plaintext)
    except Exception as e:
        msg = 'not a wallet file: ' + str(e)
        if password:
            msg = "incorrect password (or " + msg + ")"
        raise ValueError(msg)
    
    f = open('parsed_wallet.txt','w')
    f.write(pb_wallet.__str__())
    f.close()
    
    foundAddr = []
    
    for trans in pb_wallet.transaction:
      if trans.pool == 4:
        print("--------------------------------------------------------------------------------")
        print("TXID: " + binascii.hexlify(trans.hash))
        for out in trans.transaction_output:
          print("")
          faddr = bitcoin.bin_to_b58check(bitcoin.deserialize_script(out.script_bytes)[2])
          print("Addr: " + faddr)
          foundAddr.append(faddr)
          print("Amt: " + str(out.value * 0.00000001) + " BTC")
        print("")
        print("--------------------------------------------------------------------------------")
    
    seed = None
    
    sys.stdout.write('Finding Seed....')
    
    salt = pb_wallet.encryption_parameters.salt
    dkey = pylibscrypt.scrypt(password.encode('utf_16_be'), salt, olen=32)
    
    for wkey in pb_wallet.key:
      if wkey.type == 3:
        seed = aes256_cbc_decrypt(wkey.encrypted_deterministic_seed.encrypted_private_key, dkey, wkey.encrypted_deterministic_seed.initialisation_vector)
        break
        
    if not seed:
      print("No DETERMINISTIC_MNEMONIC seed found!")
      return None
    else:
      print("Done!")
    xprv = bitcoin.bip32_master_key(seed)
    
    xprvReceive = bitcoin.bip32_ckd(bitcoin.bip32_ckd(xprv, 2**31),0) #m/0'/0
    xprvChange = bitcoin.bip32_ckd(bitcoin.bip32_ckd(xprv, 2**31),1) #m/0'/1
    
    rcvAddr = []
    chgAddr = []
    rcvPrivKey = []
    chgPrivKey = []
    
    sys.stdout.write("Generating Addresses/Keys.")
    for x in range(0,1000):
      if x % 10 == 0:
        sys.stdout.write(".")
      childprivReceive = bitcoin.bip32_ckd(xprvReceive, x)
      childprivChange = bitcoin.bip32_ckd(xprvChange, x)
      
      pkeyReceive = bitcoin.bip32_extract_key(childprivReceive)
      pkeyChange = bitcoin.bip32_extract_key(childprivChange)
      
      #addressReceive = privtoaddr(pkeyReceive)
      #addressChange = privtoaddr(pkeyChange)
      rcvAddr.append(bitcoin.privtoaddr(pkeyReceive))
      chgAddr.append(bitcoin.privtoaddr(pkeyChange))
      
      rcvPrivKey.append(bitcoin.encode_privkey(pkeyReceive, 'wif_compressed'))
      chgPrivKey.append(bitcoin.encode_privkey(pkeyChange, 'wif_compressed'))
    print("Done!")  
    
    print("--------------------------------------------------------------------------------")
    
    for addy in foundAddr:
      if addy in rcvAddr:
        print("")
        print("Found Address: " + addy)
        print("PrivateKey: " + rcvPrivKey[rcvAddr.index(addy)])
      elif addy in chgAddr:
        print("")
        print("Found Change Address: " + addy)
        print("PrivateKey: " + chgPrivKey[chgAddr.index(addy)])
      else:
        print("")
        print("Address not found: " + addy)
    
    print("")
    print("--------------------------------------------------------------------------------")
      
    return pb_wallet
コード例 #28
0
 def b58encode_signature(sig, magicbyte):
     return bitcoin.bin_to_b58check(sig, magicbyte=magicbyte)