def test_demo_user_keys(self): sk_base58 = b"29oiwbqkhLGBuX5teL5d2vsiJ3EXk3dpyBiPwA7W9DJG" sk_decoded = base58.b58decode(sk_base58) hash = pyscrypt.hash(password=b"demouser", salt=b"demouser", N=1024, r=1, p=1, dkLen=32) sk = base58.b58encode(hash) hex_sk = binascii.b2a_hex(hash) print('Secret Key:', sk, 'length: ', len(sk)) self.assertEqual(sk_base58, sk) self.assertEqual(sk_decoded, hash) #print(sk) keypair = libnacl.public.SecretKey(hash) # 2ipFYsqXnrw4Mt2RUWzEQntAH1FEFB8R52rAT3eExn9S pk_base58 = base58.b58encode(keypair.pk) pk_decoded = base58.b58decode(pk_base58) self.assertEqual(pk_decoded, keypair.pk) print('Public Key:', pk_base58, 'length: ', len(pk_base58)) print("XID: ", crypto.key_to_xid(keypair.pk))
def dump_keys(db_env, addressStart, outputFileName): db = DB(db_env) try: r = db.open("wallet.dat", "main", DB_BTREE, DB_THREAD|DB_RDONLY) except DBError: logging.error("Couldn't open addr.dat/main. Try quitting Bitcoin and running this again.") return cString = cStringIO.StringIO() kds = BCDataStream() vds = BCDataStream() for (key, value) in db.items(): kds.clear(); kds.write(key) vds.clear(); vds.write(value) type = kds.read_string() if type == "key": publicKey = kds.read_bytes(kds.read_compact_size()) privateKey = vds.read_bytes(vds.read_compact_size()) address = public_key_to_bc_address(publicKey) if address.startswith(addressStart): privateKey58 = b58encode(privateKey) cString.write('%s\n' % privateKey58) print("\nPubKey hex: "+ long_hex(publicKey) + "\nPubKey base58: "+ b58encode(publicKey) + "\nAddress: " + address + "\nPriKey hex: "+ long_hex(privateKey) + "\nPriKey base58: "+ privateKey58 + "\n") outputText = cString.getvalue() if outputText != '': writeFileText(outputFileName, outputText) db.close()
def invalid_values(valid_value): return [ valid_value[:-2], valid_value[:-5], valid_value + '0', valid_value + base58.b58encode(b'0').decode("utf-8"), valid_value + base58.b58encode(b'somefake').decode("utf-8"), base58.b58encode(b'somefakevaluesomefakevalue').decode("utf-8") ]
def invalid_short_values(valid_value): return [ valid_value[:1], valid_value[:2], valid_value[:5], '', base58.b58encode(b'1' * 10).decode("utf-8"), base58.b58encode(b'1' * 2).decode("utf-8") ]
def replica(replica): replica.node.requests = Requests() replica.isMaster = True replica.node.replica = replica replica.node.doDynamicValidation = functools.partial(randomDynamicValidation, replica.node) replica.node.applyReq = lambda self, *args, **kwargs: True replica.stateRootHash = lambda self, *args, **kwargs: base58.b58encode(randomString(32)).decode() replica.txnRootHash = lambda self, *args, **kwargs: base58.b58encode(randomString(32)).decode() replica.node.onBatchCreated = lambda self, *args, **kwargs: True replica.requestQueues[DOMAIN_LEDGER_ID] = OrderedSet() return replica
def ed25519_generate_key_pair(): """ Generate a new key pair and return the pair encoded in base58 """ sk, vk = ed25519.create_keypair() # Private key private_value_base58 = Ed25519SigningKey(base58.b58encode(sk.to_bytes())).to_ascii() # Public key public_value_compressed_base58 = Ed25519VerifyingKey(base58.b58encode(vk.to_bytes())).to_ascii() return private_value_base58, public_value_compressed_base58
def to_dict(self): """ Generate a dict of the fulfillment Returns: dict: representing the fulfillment """ return { 'type': Ed25519Sha256.TYPE_NAME, 'public_key': base58.b58encode(self.public_key), 'signature': base58.b58encode(self.signature) if self.signature else None }
def test_generate_keypair(self): bob = libnacl.public.SecretKey() assert bob is not None self.assertEqual(len(bob.sk), 32) sk = base58.b58encode(bob.sk) pk = base58.b58encode(bob.pk) xid = crypto.key_to_xid(bob.pk) print("Public key: ", pk, ", len: ", len(pk)) print("Secret key: ", sk, ", len: ", len(sk)) print("XID: ", xid, ", len: ", len(xid))
def doAttrDisclose(self, origin, target, txnId, key): box = libnacl.public.Box(b58decode(origin), b58decode(target)) data = json.dumps({TXN_ID: txnId, SKEY: key}) nonce, boxedMsg = box.encrypt(data.encode(), pack_nonce=False) op = { TARGET_NYM: target, TXN_TYPE: DISCLO, NONCE: b58encode(nonce).decode("utf-8"), DATA: b58encode(boxedMsg).decode("utf-8") } self.submit(op, identifier=origin)
def encode_address(self, ip, port): ip = socket.inet_aton(ip) port = struct.pack("!H", port) data = ip + port h = base58.checksum(data) data += h[:4] return base58.b58encode(data)
def base58encoding(filename, type): image = open(filename) serializedImage = base58.b58encode(image.read()) createTmp58File(serializedImage) getTempFilesSize(filename) #base58decoding(serializedImage) return serializedImage
def testNodeKeysChanged(looper, txnPoolNodeSet, tdir, tconf, sdk_node_theta_added, sdk_pool_handle, allPluginsPath=None): new_steward_wallet, new_node = sdk_node_theta_added new_node.stop() looper.removeProdable(name=new_node.name) nodeHa, nodeCHa = HA(*new_node.nodestack.ha), HA(*new_node.clientstack.ha) sigseed = randomString(32).encode() verkey = base58.b58encode(SimpleSigner(seed=sigseed).naclSigner.verraw).decode("utf-8") sdk_change_node_keys(looper, new_node, new_steward_wallet, sdk_pool_handle, verkey) config_helper = PNodeConfigHelper(new_node.name, tconf, chroot=tdir) initNodeKeysForBothStacks(new_node.name, config_helper.keys_dir, sigseed, override=True) logger.debug("{} starting with HAs {} {}".format(new_node, nodeHa, nodeCHa)) node = TestNode(new_node.name, config_helper=config_helper, config=tconf, ha=nodeHa, cliha=nodeCHa, pluginPaths=allPluginsPath) looper.add(node) # The last element of `txnPoolNodeSet` is the node Theta that was just # stopped txnPoolNodeSet[-1] = node looper.run(checkNodesConnected(txnPoolNodeSet)) waitNodeDataEquality(looper, node, *txnPoolNodeSet[:-1]) sdk_ensure_pool_functional(looper, txnPoolNodeSet, new_steward_wallet, sdk_pool_handle)
def hash_to_address_multichain(version, hash, checksum): """ Format address the MultiChain way, with version bytes and checksum bytes. http://www.multichain.com/developers/address-format/ :param version: :param hash: :param checksum: :return: """ n = len(version) pos = 0 i =0 vh = '' while i<n: vh += version[i:i+1] vh += hash[pos:pos+5] i += 1 pos += 5 vh += hash[pos:] dh = double_sha256(vh) a = dh[:4] b = checksum new_checksum = ''.join([chr(ord(x) ^ ord(y)) for (x, y) in zip(a, b[:len(a)])]) vh += new_checksum[:4] return base58.b58encode(vh)
def to_extended_key(self, include_prv=False): if not self.__testnet: version = 0x0488B21E if not include_prv else 0x0488ADE4 else: version = 0x043587CF if not include_prv else 0x04358394 version = util.number_to_string(version, 2**32-1) depth = util.number_to_string(self.__depth, 2**8-1) parentfp = self.parentfp() childnum = util.number_to_string(self.__childnum, 2**32-1) chaincode = self.__chain if include_prv: if self.__prvkey == None: raise Exception('private key unkown') data = '\x00' + util.number_to_string(self.__prvkey, SECP256k1.order) else: # compress point data = point_compress(self.point()) import base58 ekdata = ''.join([version, depth, parentfp, childnum, chaincode, data]) checksum=hashlib.sha256(hashlib.sha256(ekdata).digest()).digest()[:4] return base58.b58encode(ekdata + checksum)
def create_bls_multi_sig(encoded_root_hash): pool_state_root_hash = base58.b58encode(b"somefakepoolroothashsomefakepoolroothash").decode("utf-8") txn_root_hash = base58.b58encode(b"somefaketxnroothashsomefaketxnroothash").decode("utf-8") ledger_id = 1 timestamp = get_utc_epoch() value = MultiSignatureValue(ledger_id=ledger_id, state_root_hash=encoded_root_hash, pool_state_root_hash=pool_state_root_hash, txn_root_hash=txn_root_hash, timestamp=timestamp) sign = "1q" * 16 participants = ["q" * 32, "w" * 32, "e" * 32, "r" * 32] return MultiSignature(sign, participants, value)
def encode(data: Union[str, bytes]) -> str: """ Return Base58 string from data :param data: Bytes or string data """ return ensure_str(base58.b58encode(ensure_bytes(data)))
def key_to_fingerprint(key): """ Fingerprint is used to uniquely identify an entity without exposing extra information. :param key: the public key :return: """ #assert len(key) == 32 sha256 = hashlib.sha256() sha256.update(key) key_hash = sha256.digest() #print('%r' % key_hash) #assert len(key_hash) == 32 ripemd = hashlib.new('ripemd') ripemd.update(key_hash) key_hash = ripemd.digest() #assert len(key_hash) == 20 sha256 = hashlib.sha256() sha256.update(FINGER_PREFIX) sha256.update(key_hash) checksum = sha256.digest() result = FINGER_PREFIX+key_hash+checksum[:4] return base58.b58encode(result)
def bip38_encrypt(privkey,passphrase): '''BIP0038 non-ec-multiply encryption. Returns BIP0038 encrypted privkey.''' privformat = get_privkey_format(privkey) if privformat in ['wif_compressed','hex_compressed']: compressed = True flagbyte = '\xe0' if privformat == 'wif_compressed': privkey = encode_privkey(privkey,'hex_compressed') privformat = get_privkey_format(privkey) if privformat in ['wif', 'hex']: compressed = False flagbyte = '\xc0' if privformat == 'wif': privkey = encode_privkey(privkey,'hex') privformat = get_privkey_format(privkey) pubkey = privtopub(privkey) addr = pubtoaddr(pubkey) addresshash = hashlib.sha256(hashlib.sha256(addr).digest()).digest()[0:4] key = scrypt.hash(passphrase, addresshash, 16384, 8, 8) derivedhalf1 = key[0:32] derivedhalf2 = key[32:64] aes = AES.new(derivedhalf2) encryptedhalf1 = aes.encrypt(binascii.unhexlify('%0.32x' % (long(privkey[0:32], 16) ^ long(binascii.hexlify(derivedhalf1[0:16]), 16)))) encryptedhalf2 = aes.encrypt(binascii.unhexlify('%0.32x' % (long(privkey[32:64], 16) ^ long(binascii.hexlify(derivedhalf1[16:32]), 16)))) encrypted_privkey = ('\x01\x42' + flagbyte + addresshash + encryptedhalf1 + encryptedhalf2) encrypted_privkey += hashlib.sha256(hashlib.sha256(encrypted_privkey).digest()).digest()[:4] # b58check for encrypted privkey encrypted_privkey = base58.b58encode(encrypted_privkey) return encrypted_privkey
def process_response(self, request, response): """ If we have multiple Set-Cookies, combine them into a single ZappaCookie. Returns the modified HTTP Response. """ if not response.cookies.keys(): return response # If setting cookie on a 301/2, # return 200 and replace the content with a javascript redirector if response.status_code != 200 and response.has_header('Location'): location = response.get('Location') response.content = REDIRECT_HTML.replace('REDIRECT_ME', location) response.status_code = 200 pack = {} for key in response.cookies.keys(): pack[key] = response.cookies[key].value del(response.cookies[key]) pack_s = json.dumps(pack) encoded = base58.b58encode(pack_s) response.set_cookie('zappa', encoded) return response
def test_round_trips(): possible_bytes = [b'\x00', b'\x01', b'\x10', b'\xff'] for length in range(0, 5): for bytes_to_test in product(possible_bytes, repeat=length): bytes_in = b''.join(bytes_to_test) bytes_out = b58decode(b58encode(bytes_in)) assert_that(bytes_in, equal_to(bytes_out))
def encode(private_value): """ Encode the decimal number private_value to base58 """ private_value_hex = bitcoin.encode_privkey(private_value, "hex") private_value_base58 = base58.b58encode(bytes.fromhex(private_value_hex)) return private_value_base58
def injecting_start_response(status, headers, exc_info=None): # Iterate through the headers looking for Set-Cookie updates = False for idx, (header, value) in enumerate(headers): if header == 'Set-Cookie': cookie = parse_cookie(value) if 'zappa' in cookie: # We found a header in the response object that sets # zappa as a cookie. Delete it. del(headers[idx]) del(cookie['zappa']) print 'deleted zappa set-cooke header' print 'remaining cookie', cookie if cookie: updates = True request_cookies.update(cookie) print 'setting cookie', cookie # Encode cookies into Zappa cookie if updates and request_cookies: final_cookies = ["{cookie}={value}".format(cookie=k, value=v) for k, v in request_cookies.items()] encoded = base58.b58encode(';'.join(final_cookies)) headers.append(('Set-Cookie', dump_cookie('zappa', value=encoded))) return start_response(status, headers, exc_info)
def pubkey_to_addr(pubkey, net=BC): # Addresses: # https://en.bitcoin.it/wiki/Protocol_documentation keyhash = net.pubkeyprefix + ripesha(pubkey).digest() checksum = shasha(keyhash).digest()[:4] address = b58encode(keyhash + checksum) return address
def encode(public_value_x, public_value_y): """ Encode the public key represented by the decimal values x and y to base58 """ public_value_compressed_hex = bitcoin.encode_pubkey([public_value_x, public_value_y], "hex_compressed") public_value_compressed_base58 = base58.b58encode(bytes.fromhex(public_value_compressed_hex)) return public_value_compressed_base58
def private_key_to_human(private_key, advanced): """ this function takes a 32 byte ed25519 private key in binary form and returns a string with a human readable private key according to this spec: https://github.com/FactomProject/FactomDocs/blob/master/factomDataStructureDetails.md#factoid-private-keys For example. a binary private key passed like this : 12fab77add10bcabe1b62b3fe8b167e966e4beee38ccf0062fdd207b5906c841 would return this string: Fs1Ts7PsKMwo4ftCYxQJ3rW4pLiRBXyGEjMrxtHycLu52aDgKGEy The advanced parameter set to true displays technical internal data """ hex_seed = private_key.encode('hex') private_key_prefix = factoid_secret_key_prefix + hex_seed if advanced == True: print "Private key with prefix: " + private_key_prefix digest = hashlib.sha256(hashlib.sha256(private_key_prefix.decode("hex")).digest()).digest() if advanced == True: print "Private key hash: " + digest.encode('hex') checksummed_private_key = private_key_prefix + digest[:4].encode('hex') if advanced == True: print "Private key with checksum: " + checksummed_private_key human_privkey = base58.b58encode(checksummed_private_key.decode("hex")) if advanced == True: print "Human readable private key: " + human_privkey return human_privkey
def sdk_change_bls_key(looper, txnPoolNodeSet, node, sdk_pool_handle, sdk_wallet_steward, add_wrong=False, new_bls=None): new_blspk = init_bls_keys(node.keys_dir, node.name) key_in_txn = new_bls or new_blspk \ if not add_wrong \ else base58.b58encode(randomString(128).encode()) node_dest = hexToFriendly(node.nodestack.verhex) sdk_send_update_node(looper, sdk_wallet_steward, sdk_pool_handle, node_dest, node.name, None, None, None, None, bls_key=key_in_txn, services=None) poolSetExceptOne = list(txnPoolNodeSet) poolSetExceptOne.remove(node) waitNodeDataEquality(looper, node, *poolSetExceptOne) sdk_pool_refresh(looper, sdk_pool_handle) sdk_add_new_nym(looper, sdk_pool_handle, sdk_wallet_steward, alias=randomString(5)) ensure_all_nodes_have_same_data(looper, txnPoolNodeSet) return new_blspk
def pre_prepare_with_incorrect_bls_pool_ledger(multi_signature): multi_signature.signature = base58.b58encode(b"somefakesignaturesomefakesignaturesomefakesignature").decode("utf-8") params = create_pre_prepare_params(state_root=multi_signature.value.state_root_hash, pool_state_root=multi_signature.value.pool_state_root_hash, bls_multi_sig=multi_signature, ledger_id=POOL_LEDGER_ID) return PrePrepare(*params)
def _fulfillment_to_details(fulfillment): """ Encode a fulfillment as a details dictionary Args: fulfillment: Crypto-conditions Fulfillment object """ if fulfillment.type_name == 'ed25519-sha-256': return { 'type': 'ed25519-sha-256', 'public_key': base58.b58encode(fulfillment.public_key), } if fulfillment.type_name == 'threshold-sha-256': subconditions = [ _fulfillment_to_details(cond['body']) for cond in fulfillment.subconditions ] return { 'type': 'threshold-sha-256', 'threshold': fulfillment.threshold, 'subconditions': subconditions, } raise UnsupportedTypeError(fulfillment.type_name)
def from_hash160(h160, currency='btc', typ='pub', version=None): """Create crypto currency address from hash160 digest. :h160: string, digest hash160 to create address from. :currency: string, three letter code for the currency :typ: string, type of address 'priv' for private addresses or 'pub' for public addresses :version: int, prefix for any other currency, if set params currency and typ are ignored :returns: string, Base58 encoded address """ if all(c in string.hexdigits for c in h160): h160 = h160.decode('hex') currency = currency.lower() if currency not in versions.keys(): raise Exception('Currency %s is unknown.' % currency) if version is None: version = versions[currency][typ] h160 = chr(version) + h160 h = dhash(h160) addr = h160 + h[0:4] pad = 0 for c in h160: if c == chr(0): pad += 1 else: break return base58.alphabet[0] * pad + base58.b58encode(addr)
def client1Signer(): seed = b'client1Signer secret key........' signer = DidSigner(seed=seed) testable_verkey = friendlyToRaw(signer.identifier) testable_verkey += friendlyToRaw(signer.verkey[1:]) testable_verkey = base58.b58encode(testable_verkey) assert testable_verkey == '6JvpZp2haQgisbXEXE9NE6n3Tuv77MZb5HdF9jS5qY8m' return signer
print("---------------------------------------") output = hashHex('sha256', publicKeyHex) print("apply sha-256 to public key: ", output) output = hashHex('ripemd160', output) print("apply ripemd160 to sha-256 applied public key: ", output) output = "00" + output print("add network bytes to ripemd160 applied hash - extended ripemd160: ", output, "\n") print("checksum calculation") checksum = hashHex('sha256', output) print("apply sha-256 to extended ripemd160: ", checksum) checksum = hashHex('sha256', checksum) print("apply second time sha-256: ", checksum) checksum = checksum[0:8] print("extract first 8 characters as checksum: ", checksum) address = output + checksum print("append checksum to extended ripemd160", address) print("---------------------------------------") import base58 address = base58.b58encode(hexStringToByte(address)) print("this is your bitcoin address:", str(address)[2:len(address) - 2])
#create p2sh address #1 OP_ADD[0x93] 01 0x63 OP_EQUAL[0x87] #OP_CHECKSIGVERIFY [0xad] #OP_1 [0x51] #OP_MUL [0x95] #0xAD OP_1 OP_1 OP_MUL redeemScript = 'ad515195' #2 Generate scriptPubKey as OP_HASH160 hash160(redeemScript) OP_EQUAL data = hash160(redeemScript.decode('hex')).encode('hex') print data scriptPubKey = 'a914' + data + '87' version = '05' #mainnet version = 'c4' #testnet data = version + data #print EncodeBase58Check(data.decode('hex')) #3 Generate address with 0x05 prefix and double SHA256 hash checksum(=4bytes) checksum = dhash256(data.decode('hex')) checksum = checksum.encode('hex')[0:8] addressHash = data + checksum #4 bash58encode address = b58encode(addressHash.decode('hex')) print address #2My2ApqGcoNXYceZC4d7fipBu4GodkbefHD
def generate_state_root(): return base58.b58encode(os.urandom(32)).decode("utf-8")
# there is a method to output the curve coordinates in decimal # outputs coordinates: the (x,y) point on the curve print(public_key.public_numbers()) x_coord = public_key.public_numbers()._x # convert to hex pub_key_hex = hex(x_coord) # strip the first two characters signifying python hex number pub_key_hex = pub_key_hex[2:] # append the prefix 03 indicating that the y-value was odd # with this code, half the address should not validate pub_key_hex = '03'+pub_key_hex import hashlib # double-hashed first as sha256, then as ripemd160 temp = hashlib.sha256(pub_key_hex.encode()) pub_key_hash = hashlib.new('ripemd160',temp.digest()).digest() # prefix a zero byte for a bitcoin address pub_key_hash = bytes.fromhex('00')+pub_key_hash # double sha256 hash and take the first 4 bytes as a checksum dubhash = hashlib.sha256(hashlib.sha256(pub_key_hash).digest()).digest() checksum = dubhash[:4] pub_key_hash = pub_key_hash + checksum # now convert to base58 encoding # may have to >>> pip install base58 import base58 b58 = base58.b58encode(pub_key_hash) btc_address = b58.decode() print(btc_address)
#!/usr/bin/python # -*- coding: utf-8 -*- #facilisimoDeveloper: roberto import pywaves as pw import base58 pw.setChain(chain='L') newAddress = pw.Address() encodeSeed = base58.b58encode(newAddress.seed.encode('utf-8')) print "---Wallet encoded seed---" print encodeSeed print "" print "---data Address---" print newAddress
def __verkey(self): return base58.b58encode(self._node.nodestack.verKey).decode("utf-8")
# Front end settings bind_address = "127.0.0.1" bind_port = 6771 db_url = "sqlite:///gateway.db" waves_api_url = "http://127.0.0.1:6869" waves_api_key = "evik904i5v9mgoupgsnio" testnet = True gateway_address = "3N3qmHa1MBo3ZjDYJZbHNezY4RfhtTFxjXG" gateway_private_key = b'\x88rz\x037{\xfb\xa1\xb3e\\^\xcb\x97\x8d\xa1q\xe0$\xaa\xd7"\xeeI\xff\xf9!Jt~pa' import curve25519, base58 gateway_public_key = curve25519.public(gateway_private_key) print("Gateway's public key:", gateway_public_key, base58.b58encode(gateway_public_key)) default_fee = 100000 #currencies = {"3k2qVm2BSGvjCXNBGdFwq5mYSrd4LJmVgfBGro4qRQ1W": "mock_bank_usd"} currencies = {"CcvuevJVhadmRipPQgWkGDreUcdnRGWjBJ2ey7mzop9g": "dogecoin"} required_confirmations = 0 start_from_block = 3961 rescan_blockchain = False import logging logging.getLogger("requests").setLevel(logging.WARNING) logging.getLogger("urllib3").setLevel(logging.WARNING)
def id_b58_encode(peer_id): """ return a b58-encoded string """ #pylint: disable=protected-access return base58.b58encode(peer_id._id_str).decode()
def pretty(self): return base58.b58encode(self._id_str).decode()
def hash_to_address(version, hash): vh = version + hash return base58.b58encode(vh + double_sha256(vh)[:4])
def generate_new_id(self) -> None: """Randomly generate an ID representing this report's execution.""" self.report_id = base58.b58encode(uuid.uuid4().bytes).decode()
password=conf.db.pwd, database=conf.db.db, port=conf.db.port) cursor = conn.cursor() i = 0 while (True): try: sql = "SELECT * FROM incoming ORDER BY id ASC LIMIT 1" cursor.execute(sql, []) data = cursor.fetchall() if not data: time.sleep(10) continue address = base58.b58encode(data[0][1]) # was stored and is saved without version bit public = [address] cursor.execute("INSERT INTO public(address) values(%s)", public) archive = [cursor.lastrowid, data[0][2]] cursor.execute("INSERT INTO archive(public_id, pkey) values(%s,%s)", archive) cursor.execute("DELETE FROM incoming WHERE id = %s", [data[0][0]]) conn.commit() i += 1 print(str(i)) except MySQLdb.Error, e: print e[0], e[1]
def Encode(text): text = text.encode('UTF-8') return base58.b58encode(text)
def btc_key_to_wif(private_key): fullkey = '80' + binascii.hexlify(bytes.fromhex(private_key)).decode() sha256a = hashlib.sha256(binascii.unhexlify(fullkey)).hexdigest() sha256b = hashlib.sha256(binascii.unhexlify(sha256a)).hexdigest() WIF = base58.b58encode(binascii.unhexlify(fullkey + sha256b[:8])) return WIF.decode()
def _acquire_access_token(self): self._token = os.environ.get('AVA_ACCESS_TOKEN', base58.b58encode(os.urandom(16)))
if args.path is None: args.path = "48'/13'/0'/0'/0'" donglePath = parse_bip32_path(args.path) apdu = "D4020001".decode('hex') + chr(len(donglePath) + 1) + chr( len(donglePath) / 4) + donglePath dongle = getDongle(True) result = dongle.exchange(bytes(apdu)) offset = 1 + result[0] address = result[offset + 1:offset + 1 + result[offset]] public_key = result[1:1 + result[0]] head = 0x03 if (public_key[64] & 0x01) == 1 else 0x02 public_key_compressed = bytearray([head]) + public_key[1:33] print " Public key " + str(public_key).encode('hex') print "Public key compressed " + str(public_key_compressed).encode('hex') ripemd = hashlib.new('ripemd160') ripemd.update(public_key_compressed) check = ripemd.digest()[:4] buff = public_key_compressed + check print "Calculated from public key: Address STM" + b58encode(str(buff)) print " Received from ledger: Address " + str(address) apdu = "D4020101".decode('hex') + chr(len(donglePath) + 1) + chr( len(donglePath) / 4) + donglePath result = dongle.exchange(bytes(apdu))
def __node_info(self): ledger_statuses = {} waiting_cp = {} num_txns_in_catchup = {} last_txn_3PC_keys = {} committed_ledger_root_hashes = {} uncommited_ledger_root_hashes = {} uncommitted_ledger_txns = {} committed_state_root_hashes = {} uncommitted_state_root_hashes = {} for idx, linfo in self._node.ledgerManager.ledgerRegistry.items(): ledger_statuses[idx] = self._prepare_for_json(linfo.state.name) waiting_cp[idx] = self._prepare_for_json(linfo.catchUpTill) num_txns_in_catchup[idx] = self._prepare_for_json( linfo.num_txns_caught_up) last_txn_3PC_keys[idx] = self._prepare_for_json( linfo.last_txn_3PC_key) if linfo.ledger.uncommittedRootHash: uncommited_ledger_root_hashes[idx] = self._prepare_for_json( base58.b58encode(linfo.ledger.uncommittedRootHash)) txns = {"Count": len(linfo.ledger.uncommittedTxns)} if len(linfo.ledger.uncommittedTxns) > 0: txns["First_txn"] = self._prepare_for_json( linfo.ledger.uncommittedTxns[0]) txns["Last_txn"] = self._prepare_for_json( linfo.ledger.uncommittedTxns[-1]) uncommitted_ledger_txns[idx] = txns if linfo.ledger.tree.root_hash: committed_ledger_root_hashes[idx] = self._prepare_for_json( base58.b58encode(linfo.ledger.tree.root_hash)) for l_id, req_handler in self._node.ledger_to_req_handler.items(): committed_state_root_hashes[l_id] = self._prepare_for_json( base58.b58encode(req_handler.state.committedHeadHash)) uncommitted_state_root_hashes[l_id] = self._prepare_for_json( base58.b58encode(req_handler.state.headHash)) return { "Node_info": { "Name": self._prepare_for_json(self.__alias), "Mode": self._prepare_for_json(self._node.mode.name), "Client_port": self._prepare_for_json(self.__client_port), "Client_protocol": self._prepare_for_json(ZMQ_NETWORK_PROTOCOL), "Node_port": self._prepare_for_json(self.__node_port), "Node_protocol": self._prepare_for_json(ZMQ_NETWORK_PROTOCOL), "did": self._prepare_for_json(self.__did), 'verkey': self._prepare_for_json(self.__verkey), "Metrics": self._prepare_for_json(self._get_node_metrics()), "Committed_ledger_root_hashes": self._prepare_for_json(committed_ledger_root_hashes), "Committed_state_root_hashes": self._prepare_for_json(committed_state_root_hashes), "Uncommitted_ledger_root_hashes": self._prepare_for_json(uncommited_ledger_root_hashes), "Uncommitted_ledger_txns": self._prepare_for_json(uncommitted_ledger_txns), "Uncommitted_state_root_hashes": self._prepare_for_json(uncommitted_state_root_hashes), "View_change_status": { "View_No": self._prepare_for_json(self._node.viewNo), "VC_in_progress": self._prepare_for_json( self._node.view_changer.view_change_in_progress), "Last_view_change_started_at": self._prepare_for_json(self.__get_start_vc_ts()), "Last_complete_view_no": self._prepare_for_json( self._node.view_changer.last_completed_view_no), "IC_queue": self._prepare_for_json(self._get_ic_queue()), "VCDone_queue": self._prepare_for_json( self._node.view_changer._view_change_done) }, "Catchup_status": { "Ledger_statuses": self._prepare_for_json(ledger_statuses), "Received_LedgerStatus": "", "Waiting_consistency_proof_msgs": self._prepare_for_json(waiting_cp), "Number_txns_in_catchup": self._prepare_for_json(num_txns_in_catchup), "Last_txn_3PC_keys": self._prepare_for_json(last_txn_3PC_keys), }, "Count_of_replicas": self._prepare_for_json(len(self._node.replicas)), "Replicas_status": self._prepare_for_json(self.__replicas_status), "Pool_ledger_size": self._prepare_for_json(self._get_pool_ledger_size()), "Domain_ledger_size": self._prepare_for_json(self._get_domain_ledger_size()), "Config_ledger_size": self._prepare_for_json(self._get_config_ledger_size()), } }
def rand_str(length): res = '' lower = 'abcdefghijklmnopqrstuvwxyz' upper = lower.upper() num = '01234567890' charset = lower + upper + num for i in range(0, length): #pylint: disable=unused-variable res += random.choice(charset) return res for i in range(50): shell_snippet="""( DID='{DID}' VKEY='~{VKEY}' resp=$(curl -sSd "{{\\"network\\":\\"stagingnet\\",\\"did\\":\\"{DID}\\",\\"verkey\\":\\"~{VKEY}\\",\\"paymentaddr\\":\\"\\"}}" http://127.0.0.1:8080/nym 2>&1) if [ $? -ne 0 ] ; then echo "Request for DID: {DID} and VerKey: ~{VKEY} FAILED!!" echo "$resp" else if echo "$resp" | grep -q '"statusCode": 200' ; then echo "Request for DID: {DID} and VerKey: ~{VKEY} was successful" else echo "Request for DID: {DID} and VerKey: ~{VKEY} FAILED!!" echo "$resp" fi fi ) &""".format(DID=base58.b58encode(rand_str(16)).decode(), VKEY=base58.b58encode(rand_str(16)).decode()) print(shell_snippet) print('echo') print('wait')
import filelock import json private_key = ecdsa.SingingKey.generate(curve=ecdsa.SECP256k1) public_key = private_key.get_verifying_key() private_key = private_key.to_string() public_key = public_key.to_string() print('private key len:', len(private_key)) print('private key hex:', private_key.hex()) print('public key len:', len(public_key)) print('public key hex:', public_key.hex()) private_b58 = base58.b58encode(private_key).decode('ascii') public_b58 = base58.b58encode(public_key).decode('ascii') print('private key base58:', private_b58) print('public key base58:', public_b58) with filelock.FileLock('key.lock', timeout=10): try: with open('key.txt', 'r') as file: key_list = json.json.load(file) except: key_list = [] key_list.append({'private': private_b58, 'public': public_b58}) with open('key.txt', 'w') as file:
def address_checksum(arr): hash_val = blake2b_hash(arr) str_val = base58.b58encode(hash_val) str_val = str_val[:4] return str_val
# modification, are permitted provided that the following conditions are met: # # 1. Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS # IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, # THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. import sys try: import base58 except ImportError: exit(-1) # base58 is not installed data = sys.stdin.buffer.read() data = base58.b58encode(data) sys.stdout.buffer.write(data)
import hashlib import base58 # answer to https://bitcoin.stackexchange.com/questions/96190 # WIF to private key by https://en.bitcoin.it/wiki/Wallet_import_format Private_key = base58.b58decode_check( "5JYJWrRd7sbqEzL9KR9dYTGrxyLqZEhPtnCtcvhC5t8ZvWgS9iC") Private_key = Private_key[1:] # Private key to public key (ecdsa transformation) signing_key = ecdsa.SigningKey.from_string(Private_key, curve=ecdsa.SECP256k1) verifying_key = signing_key.get_verifying_key() public_key = bytes.fromhex("04") + verifying_key.to_string() # hash sha 256 of pubkey sha256_1 = hashlib.sha256(public_key) # hash ripemd of sha of pubkey ripemd160 = hashlib.new("ripemd160") ripemd160.update(sha256_1.digest()) # checksum hashed_public_key = bytes.fromhex("00") + ripemd160.digest() checksum_full = hashlib.sha256( hashlib.sha256(hashed_public_key).digest()).digest() checksum = checksum_full[:4] bin_addr = hashed_public_key + checksum # encode address to base58 and print result_address = base58.b58encode(bin_addr) print("Bitcoin address {}".format(result_address))
sql_statement = sqlpart1 + sqlpart2 #database = sqlite3.connect('/home/douglasrfix/IntraGalacticMediaService.db', isolation_level=None) database = sqlite3.connect('/home/douglasrfix/IntraGalacticMediaService.db') cursor = database.cursor() ipfs_server = ipfshttpclient.connect(timeout=(20.0, 400)) #uncommitedInserts = 1 #while True: try: with ipfs_server.pubsub.subscribe('IntraGalacticMediaService') as subscription: for message in subscription: decoded_message_from = base64.standard_b64decode(message['from']) base58_encoded_author_peerID = base58.b58encode(decoded_message_from) #BITCOIN_ALPHABET decoded_IPNS_name = base64.standard_b64decode(message['data']) decoded_seqno = int.from_bytes(base64.standard_b64decode(message['seqno']), byteorder='big', signed=False) string_topicIDs_list = str(message['topicIDs']) string_message = str(message) cursor.execute(sql_statement, [base58_encoded_author_peerID, decoded_IPNS_name, decoded_seqno, string_topicIDs_list, string_message]) database.commit() except requests.exceptions.ConnectionError as e: print(e) #if uncommitedInserts > 0: #database.commit() #uncommitedInserts = 0 #except KeyboardInterrupt: #database.commit()
def get_bitcoin_address(public_key, prefix=b'\x00'): ripemd160 = hashlib.new('ripemd160') ripemd160.update(hashlib.sha256(public_key).digest()) a = prefix + ripemd160.digest() checksum = hashlib.sha256(hashlib.sha256(a).digest()).digest()[0:4] return b58encode(a + checksum)
def to_base58(family): return base58.b58encode(family.encode('utf-8')).decode('utf-8')
def email_hash(self) -> str: """Public identifier string for email address, usable in URLs.""" return base58.b58encode(self.blake2b160).decode()
def hexToBase58(key): payload_str = '1C' + key payload_unhex = binascii.unhexlify(payload_str) checksum = doubleSha256(payload_str)[0:4] return base58.b58encode(payload_unhex + checksum, base58.RIPPLE_ALPHABET)
def rawToFriendly(self, raw): return base58.b58encode(raw).decode("utf-8")
def hashToStr(h): return base58.b58encode(h)
def address_to_string(public_key): return "H" + base58.b58encode(public_key) + address_checksum(public_key)