def private_key_to_wif(private_key): decode_hex = codecs.getdecoder("hex_codec") encode_hex = codecs.getencoder("hex_codec") output = Qtum.validate_private_key_for_wif(private_key) extended_private_key = output #print(output) output = decode_hex(output)[0] output = sha256(output).digest() #print(encode_hex(output)[0]) output = sha256(output).digest() #print(encode_hex(output)[0]) output = encode_hex(output)[0] checksum = output[:8] output = extended_private_key + checksum.decode() #print(output) output = decode_hex(output)[0] #print('my_raw:' + str(output)) output = base58check.b58encode(output) #print(output) return output.decode()
def pub_to_addr(pub_key): """Returns an encoded base58 address for the given public key.""" sha = sha256(pub_key) ripe = ripemd160(sha) #add mainnet code ripe = b"\x00" + ripe return base58check.b58encode(ripe + sha_check_sum(ripe))
def to_wif(self, compressed=True): """Returns key in WIFC or WIF string | Pseudocode: | network_prefix = (1 byte version number) | data = network_prefix + (32 bytes number/key) [ + 0x01 if compressed ] | data_hash = SHA-256( SHA-256( data ) ) | checksum = (first 4 bytes of data_hash) | wif = Base58CheckEncode( data + checksum ) """ # add network prefix to the key data = NETWORK_WIF_PREFIXES[get_network()] + self.to_bytes() if compressed == True: data += b'\x01' # double hash and get the first 4 bytes for checksum data_hash = hashlib.sha256(hashlib.sha256(data).digest()).digest() checksum = data_hash[0:4] # suffix the key bytes with the checksum and encode to base58check wif = b58encode(data + checksum) return wif.decode('utf-8')
def priv_to_WIF(priv_key): """Returns the WIF key (encoded in base 58) given a private key.""" #adds mainnet locator priv_key = b"\x80" + priv_key #runs two rounds of sha256 to get checksum checksum = sha_check_sum(priv_key) return base58check.b58encode(priv_key + checksum)
def from_xpub( xpub: str, xpub_type: Optional[XpubType] = None, path: Optional[str] = None, ) -> 'HDKey': """ Instantiate an HDKey from an xpub. Populates all possible fields Args: xpub (str): the xpub path (str): the path if it's known. useful for calling derive_path Returns: (HDKey): the key object May raise: - XPUBError if there is a problem with decoding the xpub """ xpub_bytes = b58decode(xpub) if len(xpub_bytes) < 78: raise XPUBError(f'Given XPUB {xpub} is too small') try: pubkey = PublicKey(xpub_bytes[45:78]) except ValueError as e: raise XPUBError(str(e)) from e result = _parse_prefix(xpub_bytes[0:4]) if not result.is_public: raise XPUBError('Given xpub is an extended private key') if result.network != 'mainnet': raise XPUBError('Given xpub is not for the bitcoin mainnet') hint = result.hint if xpub_type is not None and xpub_type.matches_prefix( xpub[0:4]) is False: # the given type does not match the prefix, re-encode with correct pref new_xpub = bytearray() new_xpub.extend(xpub_type.prefix_bytes()) new_xpub.extend(xpub_bytes[4:]) new_xpub_bytes = new_xpub hint = xpub_type.prefix() xpub = b58encode(bytes(new_xpub_bytes)).decode('ascii') return HDKey( path=path, network=result.network, depth=xpub_bytes[4], parent_fingerprint=xpub_bytes[5:9], index=int.from_bytes(xpub_bytes[9:13], byteorder='big'), parent=None, chain_code=xpub_bytes[13:45], fingerprint=hash160(pubkey.format(COMPRESSED_PUBKEY))[:4], xpriv=None, xpub=xpub, privkey=None, pubkey=pubkey, hint=hint, )
def seckey_to_wif(seckey: str, testnet=True): if testnet: version = 'ef' else: version = '80' seckey = version + seckey checksum = create_hash_from_string(create_hash_from_string(seckey))[0:8] cat = seckey + checksum return base58check.b58encode(bytes.fromhex(cat)).decode()
def getNewAddress(pubkey): # Version prefix for SMLY version_prefix = b'\x19' pubkeybytes = bytes.fromhex(pubkey) sha256 = hashlib.sha256(pubkeybytes).digest() ripemd160 = hashlib.new('ripemd160') ripemd160.update(sha256) payload = ripemd160.digest() checksum = hashlib.sha256(hashlib.sha256(version_prefix + payload).digest()).digest()[0:4] return base58check.b58encode(version_prefix + payload + checksum)
def hex_to_p2pkh(pubkey: str, testnet=True) -> str: #bytes_key=bytes.fromhex(pubkey) if testnet: version = '6f' # 111 else: version = '00' key_hash = version + hash160(pubkey) checksum = create_hash_from_string(create_hash_from_string(key_hash))[0:8] cat = key_hash + checksum return base58check.b58encode(bytes.fromhex(cat)).decode()
def scriptpubkey_to_p2sh_address(data: bytes) -> BTCAddress: """Return a P2SH address given a scriptpubkey P2SH: OP_HASH160 <scriptHash> OP_EQUAL """ if data[0:1] != OpCodes.op_hash160 or data[-1:] != OpCodes.op_equal: raise EncodingError(f'Invalid P2SH scriptpubkey: {data.hex()}') prefixed_hash = bytes.fromhex('05') + data[2:22] # 20 byte pubkey hash checksum = hashlib.sha256(hashlib.sha256(prefixed_hash).digest()).digest() address = base58check.b58encode(prefixed_hash + checksum[:4]) return BTCAddress(address.decode('ascii'))
def pubkey_to_base58_address(data: bytes) -> BTCAddress: """ Bitcoin pubkey to base58 address Source: https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses#How_to_create_Bitcoin_Address https://hackernoon.com/how-to-generate-bitcoin-addresses-technical-address-generation-explanation-rus3z9e May raise: - ValueError, TypeError due to b58encode """ prefixed_hash, checksum = _calculate_hash160_and_checksum(b'\x00', data) return BTCAddress(base58check.b58encode(prefixed_hash + checksum[:4]).decode('ascii'))
def private_key_to_wif(private_key, mainnet=True): output = Bip32NetworkKeys._validate_private_key_for_wif(private_key, mainnet) extended_private_key = output output = decode_hex(output)[0] checksum = sha256(sha256(output).digest()).hexdigest()[:8] output = extended_private_key + checksum output = decode_hex(output)[0] output = base58check.b58encode(output) return output.decode()
def __init__(self, entropy): # todo: init from private key entropy = entropy.encode() self.decode_hex = codecs.getdecoder("hex_codec") self.encode_hex = codecs.getencoder("hex_codec") key = BIP32Key.fromEntropy(entropy, public=False) private_key = key.PrivateKey() public_key = key.PublicKey() wif = key.WalletImportFormat() sk = SigningKey.from_string(string=private_key, curve=ecdsa.SECP256k1, hashfunc=sha256) vk = sk.get_verifying_key() #print(public_key) output = sha256(public_key).digest() #print(binascii.hexlify(output)) ripemd160 = hashlib.new('ripemd160') ripemd160.update(output) output = binascii.hexlify(ripemd160.digest()) #print(output) output = b'3A' + output # 3A is magic byte extended_ripmd160 = output #print(output) output = self.decode_hex(output)[0] output = sha256(output).digest() #print(binascii.hexlify(output)) output = sha256(output).hexdigest().encode() #print(binascii.hexlify(output)) checksum = output[:8] #print(checksum) output = extended_ripmd160 + checksum #print(output) output = self.decode_hex(output)[0] output = base58check.b58encode(output) #print(output) self.wif = wif self.private_key = private_key self.public_key = public_key self.uncompressed_public_key = vk.to_string() self.qtum_address = output
def hex_address_to_blockchain_address(hex_address, mb): output = mb + hex_address extended_ripemd160 = output output = decode_hex(output)[0] checksum = sha256(sha256(output).digest()).hexdigest()[:8] output = extended_ripemd160 + checksum output = decode_hex(output)[0] output = base58check.b58encode(output) return output.decode()
def scriptpubkey_to_p2pkh_address(data: bytes) -> BTCAddress: """Return a P2PKH address given a scriptpubkey P2PKH: OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG """ if (data[0:1] != OpCodes.op_dup or data[1:2] != OpCodes.op_hash160 or data[-2:-1] != OpCodes.op_equalverify or data[-1:] != OpCodes.op_checksig): raise EncodingError(f'Invalid P2PKH scriptpubkey: {data.hex()}') prefixed_hash = bytes.fromhex('00') + data[3:23] # 20 byte pubkey hash checksum = hashlib.sha256(hashlib.sha256(prefixed_hash).digest()).digest() address = base58check.b58encode(prefixed_hash + checksum[:4]) return BTCAddress(address.decode('ascii'))
def get_address(cls, public_key): """ 地址是用过 公钥产生,算法是 RIPEMD160(SHA256(K)) ,在经过base58check编码的 :param public_key: :return: """ ripemd160 = hashlib.new('ripemd160', hashlib.sha256( unhexlify(public_key)).digest()).digest() data = b'\x00' + ripemd160 data_2_hash = hashlib.sha256( hashlib.sha256(data).digest()).digest()[:4] # 两次hash256取前四个 data = data + data_2_hash result = base58check.b58encode(data) return result
def pubkey_to_p2sh_p2wpkh_address(data: bytes) -> BTCAddress: """Bitcoin pubkey to PS2H-P2WPKH From here: https://bitcoin.stackexchange.com/questions/75910/how-to-generate-a-native-segwit-address-and-p2sh-segwit-address-from-a-standard """ witprog = hash160(data) script = bytes.fromhex('0014') + witprog prefix = b'\x05' # this is mainnet prefix -- we don't care about testnet # prefixed_hash, checksum = _calculate_hash160_and_checksum(prefix, prefix + script) prefixed_hash, checksum = _calculate_hash160_and_checksum(prefix, script) # address = base58check.b58encode(prefix + prefixed_hash + checksum[:4]) address = base58check.b58encode(prefixed_hash + checksum[:4]) return BTCAddress(address.decode('ascii'))
def pubkey_to_base58_address(data: bytes) -> BTCAddress: """ Bitcoin pubkey to base58 address Source: https://en.bitcoin.it/wiki/Technical_background_of_version_1_Bitcoin_addresses#How_to_create_Bitcoin_Address https://hackernoon.com/how-to-generate-bitcoin-addresses-technical-address-generation-explanation-rus3z9e May raise: - ValueError, TypeError due to b58encode """ s4 = b'\x00' + hash160(data) s5 = hashlib.sha256(s4).digest() s6 = hashlib.sha256(s5).digest() return BTCAddress(base58check.b58encode(s4 + s6[:4]).decode('ascii'))
def validate(self): """Validate the address.""" if 25 > len(self.request.address) > 35: return False abytes = base58check.b58decode(self.request.address, **self.request.extras) if not abytes[0] in self.request.networks: return False checksum = sha256(sha256(abytes[:-4]).digest()).digest()[:4] if abytes[-4:] != checksum: return False return self.request.address == base58check.b58encode( abytes, **self.request.extras)
def generateWalletAddr(username, type): publicKey = getPublicKey(username, type) h = sha256() h.update(str(publicKey).encode('utf-8')) firstHash = h.hexdigest() h = new('ripemd160') h.update(str(firstHash).encode('utf-8')) ripemd160Hash = h.hexdigest() ripemd160HashExtd = '00' + ripemd160Hash h = sha256() h.update(str(ripemd160HashExtd).encode('utf-8')) hash2 = h.hexdigest() h.update(str(hash2).encode('utf-8')) hash3 = h.hexdigest() fourBytes = hash3[:8] binAddr = ripemd160HashExtd + fourBytes walletAddr = b58encode(str(binAddr).encode('utf-8')) return walletAddr.decode('ascii')
def is_valid_btc_address(value: str) -> bool: """Validates a bitcoin address for the mainnet Code is taken from: https://github.com/joeblackwaslike/coinaddr/blob/ae35c7ae550a687d9a7c2e0cb090d52edbb29cb5/coinaddr/validation.py#L67-L87 """ if 25 > len(value) > 35: return False abytes = base58check.b58decode(value) if not abytes[0] in (0x00, 0x05): return False checksum = sha256(sha256(abytes[:-4]).digest()).digest()[:4] if abytes[-4:] != checksum: return False return value == base58check.b58encode(abytes).decode()
def _make_child_xpub(self, child_pubkey: PublicKey, index: int, chain_code: bytes) -> str: """ Makes a child xpub based on the current key and the child key info. Args: child_pubkey (bytes): the child pubkey index (int): the child index chain_code (bytes): the child chain code Returns (str): the child xpub """ xpub = bytearray() xpub.extend(b58decode(cast(str, self.xpub))[0:4]) # prefix xpub.extend([cast(int, self.depth) + 1]) # depth xpub.extend(self.fingerprint) # fingerprint xpub.extend(index.to_bytes(4, byteorder='big')) # index xpub.extend(chain_code) # chain_code xpub.extend(child_pubkey.format(COMPRESSED_PUBKEY)) # pubkey (comp) return b58encode(bytes(xpub)).decode('ascii')
def hex_sig_to_b58(hexsig: str) -> str: """Translate a hex signature to a tezos b58check encoding. Params: hexsig (str): hex string encoded signature Returns: str: b58check encoding of signature """ def sha256(data): return hashlib.sha256(data).digest() bytes_sig = bytes.fromhex(hexsig) # Before translating to b58check encoding, we add a prefix at the beginning # of the sig, and a checksum at the end # The prefix enforces that the b58_sig starts with 'edsig's edsig_prefix = bytes([9, 245, 205, 134, 18]) prefixed_bytes_sig = edsig_prefix + bytes_sig checksum = sha256(sha256(prefixed_bytes_sig))[0:4] final_sig = prefixed_bytes_sig + checksum b58_sig = base58check.b58encode(final_sig) return b58_sig.decode('ascii')
def validate(self): """extended keys have their own validation""" if len(self.request.address) == 111: return self.validate_extended() """Validate the address.""" if 25 > len(self.request.address) > 35: return False try: abytes = base58check.b58decode(self.request.address, **self.request.extras) except ValueError: return False if self.network == '': return False checksum = sha256(sha256(abytes[:-4]).digest()).digest()[:4] if abytes[-4:] != checksum: return False return self.request.address == base58check.b58encode( abytes, **self.request.extras)
def to_string(self): """Returns as address string | Pseudocode: | network_prefix = (1 byte version number) | data = network_prefix + hash160_bytes | data_hash = SHA-256( SHA-256( hash160_bytes ) ) | checksum = (first 4 bytes of data_hash) | address_bytes = Base58CheckEncode( data + checksum ) """ hash160_encoded = self.hash160.encode('utf-8') hash160_bytes = unhexlify(hash160_encoded) if self.get_type() == P2PKH_ADDRESS: data = NETWORK_P2PKH_PREFIXES[get_network()] + hash160_bytes elif self.get_type() == P2SH_ADDRESS: data = NETWORK_P2SH_PREFIXES[get_network()] + hash160_bytes data_hash = hashlib.sha256(hashlib.sha256(data).digest()).digest() checksum = data_hash[0:4] address_bytes = b58encode(data + checksum) return address_bytes.decode('utf-8')
exit(0) for i in bb: for j in bb: c += 1 # Add 2 random bytes to the secret key starting wipd_test = wipd_fake_starting + i + j # Calc SHA256(WIPd) h = hashlib.sha256() h.update(wipd_test) wipd_sha256 = h.digest() # Calc SHA256(SHA256(WIPd)) h = hashlib.sha256() h.update(wipd_sha256) wipd_sha256x2 = h.digest() # Get checksum (first 4 bytes from hash) checksum = wipd_sha256x2[:4] # Concat WIPd and checksum wip_key = base58check.b58encode(wipd_test+checksum) # Generate wallet address k = key.Key.from_text(wip_key.decode()) if c % 1024 == 0: print(f'{c:5} keys checked...') if wallet == k.address(): print(f'{c:5} GOTCHA! {wallet} == {k.address()}') print(f'WIP key: {wip_key.decode()}') exit(0)
} info("Getting public keys from HSM") kvurl = 'https://' + config['kv_name_domain'] + '.vault.azure.net' kvclient = KeyVaultClient( MSIAuthentication(resource='https://vault.azure.net')) keys = kvclient.get_keys(kvurl) for key in keys: keyname = key.kid.split('/') keydat = kvclient.get_key(kvurl, keyname[-1], '').key parity = bytes([2]) if int.from_bytes(keydat.y, 'big') % 2 == 1: parity = bytes([3]) shabytes = sha256(sha256(P2PK_MAGIC + parity + keydat.x).digest()).digest()[:4] public_key = b58encode(P2PK_MAGIC + parity + keydat.x + shabytes).decode() blake2bhash = blake2b(parity + keydat.x, digest_size=20).digest() shabytes = sha256(sha256(P2HASH_MAGIC + blake2bhash).digest()).digest()[:4] pkhash = b58encode(P2HASH_MAGIC + blake2bhash + shabytes).decode() config['keys'].update( {pkhash: { 'kv_keyname': keyname[-1], 'public_key': public_key }}) info('retrieved key info: kevault keyname: ' + keyname[-1] + ' pkhash: ' + pkhash + ' - public_key: ' + public_key) @app.route('/keys/<key_hash>', methods=['POST']) def sign(key_hash):
#!/usr/bin/env python3 from hashlib import sha256, blake2b from base58check import b58encode import nacl.signing from sys import argv edsklongprefix = bytes.fromhex('2bf64e07') # decimal is { (byte) 43, (byte) 246, (byte) 78, (byte) 7 }; edpkPrefix = bytes.fromhex('0d0f25d9') # decimal is { (byte) 13, (byte) 15, (byte) 37, (byte) 217 }; tz1prefix = bytes.fromhex('06a19f') # decimal is { (byte) 6, (byte) 161, (byte) 159 }; for a in range (1, 999999999999999999): signing_key = nacl.signing.SigningKey.generate() publicbytes = signing_key.verify_key.encode() blake2bhash = blake2b(publicbytes, digest_size=20).digest() shabytes = sha256(sha256(tz1prefix + blake2bhash).digest()).digest()[:4] pkhash = b58encode(tz1prefix + blake2bhash + shabytes).decode() if pkhash[3:len(argv[1])+3] == argv[1]: privatebytes = signing_key.encode() + publicbytes prefixedprivatebytes = edsklongprefix + privatebytes shabytes = sha256(sha256(prefixedprivatebytes).digest()).digest()[:4] edsk = b58encode(prefixedprivatebytes+shabytes).decode() print(f"{a:,d}") print(edsk) print(pkhash) break if a % 10000 == 0: print(f"{a:,d}")
def gen_address(self, pubkey: bytes): log.info( f'Generating Wallet address for public key {pubkey.hex()[:4]}...') pub_ripemd = RIPEMD.new(SHA256.new(pubkey).digest()) pub_b58 = b58encode(pub_ripemd.digest()) return pub_b58
x = verifying_key.pubkey.point.x() x = pairEncode(f'{x:x}') y = verifying_key.pubkey.point.y() y = pairEncode(f'{y:x}') full_public_key = b'\x00' + x + y # Compress the public key. prefix = b'\x03' if y[-1] % 2 else b'\x02' public_key = prefix + x # Calculate the address. # Encrypt public key. public_hash = hasher(public_key, 'sha256') encrypted_public_key = hasher(public_hash, 'ripemd160') # Add network byte (main: 0x00, test:0x6f) encrypted_public_key = b'\x00' + encrypted_public_key # Calculate the checksum. checksum = hasher(encrypted_public_key, 'sha256') checksum = hasher(checksum, 'sha256') checksum = checksum[:4] # last 4 bytes # Merge mainnet key and checksum and encode with base58check to make address. address = b58encode(encrypted_public_key + checksum).decode('ascii') print(f'Private Key: {private_key:x}') print('Public Key:', public_key.hex()) print('Address:', address)
#!/usr/bin/env python3 from hashlib import sha256, blake2b from base58check import b58encode import nacl.signing edsklongprefix = bytes.fromhex( '2bf64e07') # decimal is { (byte) 43, (byte) 246, (byte) 78, (byte) 7 }; edpkPrefix = bytes.fromhex( '0d0f25d9') # decimal is { (byte) 13, (byte) 15, (byte) 37, (byte) 217 }; tz1prefix = bytes.fromhex( '06a19f') # decimal is { (byte) 6, (byte) 161, (byte) 159 }; signing_key = nacl.signing.SigningKey.generate() verify_key = signing_key.verify_key publicbytes = verify_key.encode() privatebytes = signing_key.encode() + publicbytes prefixedprivatebytes = edsklongprefix + privatebytes shabytes = sha256(sha256(prefixedprivatebytes).digest()).digest()[:4] print(b58encode(prefixedprivatebytes + shabytes).decode()) prefixedpub = edpkPrefix + publicbytes shabytes = sha256(sha256(prefixedpub).digest()).digest()[:4] print(b58encode(prefixedpub + shabytes).decode()) blake2bhash = blake2b(publicbytes, digest_size=20).digest() shabytes = sha256(sha256(tz1prefix + blake2bhash).digest()).digest()[:4] print(b58encode(tz1prefix + blake2bhash + shabytes).decode())