def fiat_shamir(fs_state: bytes,
data: Union[List[Point], List[Scalar]],
nret=2) -> Tuple[bytes, List[Scalar]]:
"""
Generates nret integer chllange values from the currnet
interaction (data) and the previous challenge values (self.fs_state),
thus fulfilling the requirement of basing the challenge on the transcript of the
prover-verifier communication up to this point
"""
# Point type
if isinstance(data[0], tuple):
data_bs: bytes = reduce(lambda acc, x: acc + B.encode_pubkey(x, 'bin'),
data, b"")
# Scalar type
elif isinstance(data[0], int):
data_bs: bytes = reduce(
lambda acc, x: acc + B.encode_privkey(x, 'bin'), data, b"")
else:
raise Exception('Invalid `data` param type for fiat_shamir')
xb: bytes = hashlib.sha256(fs_state + data_bs).digest()
challenges: List[Scalar] = []
for _ in range(nret):
challenges.append(B.encode_privkey(xb, 'decimal'))
xb = hashlib.sha256(xb).digest()
return xb, challenges
def create_wallet(self, method, input, aes_pw):
privkey = ''
if method == 'wif':
fmt = bc.get_privkey_format(input)
if fmt == 'wif':
privkey = bc.encode_privkey(input, 'hex')
elif fmt == 'wif_compressed':
privkey = bc.encode_privkey(input, 'hex_compressed')
else:
raise Exception('Unrecoginized format for private key.')
elif method == 'random':
privkey = bc.random_key()
else:
raise Exception('Unsupported method: {0}.'.format(method))
wal_addr = bc.privtoaddr(privkey, self.magic_byte)
encr_privkey = wallet.encrypt_privkey(privkey, aes_pw)
wallet.create_wallet_file(self.wallet_filename, encr_privkey, wal_addr)
# Read back from wallet to ensure consistency
encr_privkey2, wal_addr2 = wallet.read_from_wallet_file(self.wallet_filename)
privkey2 = wallet.decrypt_privkey(encr_privkey2, aes_pw)
if encr_privkey2 != encr_privkey or wal_addr2 != wal_addr:
raise Exception('Inconsistency in reading from/writing to wallet!')
if privkey2 != privkey:
raise Exception('Inconsistency in encrypting/decrypting private key!')
return
def to_wif(self):
if self._compressed:
return encode_privkey(
self._ecdsa_private_key.to_string(), 'wif_compressed')
else:
return b58check_encode(
self.to_bin(), version_byte=self.wif_version_byte())
def _decode_private_key(encoded_private_key, encoding_format='wif'):
"""
Args:
encoded_private_key: an encoded private key string
encoding_format: string indicating format such as 'wif'
Returns:
priv (bytes): bytes representation of the private key
"""
if encoding_format == 'wif':
# int to hex string
priv = pybitcointools.encode_privkey(encoded_private_key, 'hex')
# hex string to bytes
try: # check python 3
priv = priv.to_bytes(32, byteorder='big')
except AttributeError:
priv = binascii.unhexlify(priv)
elif encoding_format == 'hex':
try:
priv = encoded_private_key.to_bytes(32, byteorder='big')
except AttributeError:
priv = binascii.unhexlify(encoded_private_key)
elif encoding_format == 'bytes':
priv = encoded_private_key
else:
raise TypeError("unsupported private key format")
return secp256k1.PrivateKey(priv, ctx=__CTX__)
def do_init(config, username=None):
if username is None:
username = config.get('DEFAULT', 'username')
config.set('DEFAULT', 'username', username)
print "set username: {}".format(username)
save_config(config)
wif_filename = config.get('DEFAULT', 'key_file')
if wif_filename.endswith(".wif"):
addr_filename = wif_filename[0:-len(".wif")] + ".addr"
else:
addr_filename = wif_filename + ".addr"
if not os.path.exists(wif_filename):
try:
if not os.path.exists(os.path.dirname(wif_filename)):
os.makedirs(os.path.dirname(wif_filename))
privkey = pybitcointools.random_key()
encoded = pybitcointools.encode_privkey(privkey, 'wif')
addr = pybitcointools.privtoaddr(privkey)
with open(wif_filename, "w") as wif_fd:
print "writing file: {}".format(wif_filename)
wif_fd.write(encoded)
wif_fd.write("\n")
with open(addr_filename, "w") as addr_fd:
print "writing file: {}".format(addr_filename)
addr_fd.write(addr)
addr_fd.write("\n")
except IOError, ioe:
raise AcException("IOError: {}".format(str(ioe)))
def multiply_privkeys(p1, p2, n):
f1, f2 = get_privkey_format(p1), get_privkey_format(p2)
p = decode_privkey(p1, f1)
while n > 0:
p = (p + decode_privkey(p2, f2)) % N
n -= 1
return encode_privkey(p, f1)
def _decode_privkey(encoded_privkey, encoding_format='wif'):
"""
Args:
encoded_privkey: an encoded private key string
encoding_format: string indicating format such as 'wif'
Returns:
priv (bytes): bytes representation of the private key
"""
if encoding_format == 'wif':
# int to hex string
priv = pybitcointools.encode_privkey(encoded_privkey, 'hex')
# hex string to bytes
try: # check python 3
priv = priv.to_bytes(32, byteorder='big')
except AttributeError:
priv = binascii.unhexlify(priv)
elif encoding_format == 'hex':
try:
priv = encoded_privkey.to_bytes(32, byteorder='big')
except AttributeError:
priv = binascii.unhexlify(encoded_privkey)
else:
raise TypeError("unsupported private key format")
return secp256k1.PrivateKey(priv, ctx=__CTX__)
def create_signup_info(cls, originator_public_key_hash,
most_recent_wait_certificate_id):
with cls._lock:
# First we need to create a public/private key pair for the PoET
# enclave to use.
cls._poet_private_key = pybitcointools.random_key()
cls._poet_public_key = \
pybitcointools.privtopub(cls._poet_private_key)
cls._active_wait_timer = None
# We are going to fake out the sealing the signup data.
signup_data = {
'poet_public_key':
pybitcointools.encode_pubkey(cls._poet_public_key, 'hex'),
'poet_private_key':
pybitcointools.encode_privkey(cls._poet_private_key, 'hex')
}
sealed_signup_data = \
pybitcointools.base64.b64encode(dict2json(signup_data))
# Create a fake report
report_data = {
'originator_public_key_hash':
originator_public_key_hash.upper(),
'poet_public_key':
pybitcointools.encode_pubkey(cls._poet_public_key,
'hex').upper()
}
report = {
'report_data': pybitcointools.sha256(dict2json(report_data))
}
# Fake our "proof" data.
verification_report = {
'enclave_quote':
pybitcointools.base64.b64encode(dict2json(report)),
'pse_manifest_hash':
pybitcointools.base64.b64encode(
pybitcointools.sha256('manifest destiny')),
'nonce':
most_recent_wait_certificate_id
}
proof_data = {
'verification_report':
dict2json(verification_report),
'signature':
pybitcointools.ecdsa_sign(dict2json(verification_report),
cls._report_private_key)
}
proof_data_dict = dict2json(proof_data)
return \
EnclaveSignupInfo(
poet_public_key=signup_data['poet_public_key'],
proof_data=proof_data_dict,
anti_sybil_id=originator_public_key_hash,
sealed_signup_data=sealed_signup_data)
def _encode_privkey(privkey, encoding_format='wif'):
try: # check python3
priv = int.from_bytes(privkey.private_key, byteorder='big')
except AttributeError:
priv = binascii.hexlify(privkey.private_key)
encoded = pybitcointools.encode_privkey(priv, encoding_format)
return encoded
def get_shared_secret(server_pub_key, private_key):
user_pub_key = get_pub_key(private_key)
network_code = get_network_code(private_key)
uncompressed_user_key = binascii.unhexlify(pybitcointools.decompress(user_pub_key))
uncompressed_server_key = binascii.unhexlify(pybitcointools.decompress(server_pub_key))
user_priv_key_bin = binascii.unhexlify(pybitcointools.encode_privkey(private_key, 'hex', network_code))
user = pyelliptic.ECC(privkey=user_priv_key_bin, pubkey=uncompressed_user_key, curve='secp256k1')
shared_secret = user.get_ecdh_key(uncompressed_server_key)
return shared_secret
def _encode_privkey(privkey, encoding_format='wif'):
try: # check python3
priv = int.from_bytes(privkey.private_key, byteorder='big')
except AttributeError:
priv = binascii.hexlify(privkey.private_key)
encoded = pybitcointools.encode_privkey(priv, encoding_format)
return encoded
def on_validator_discovered(self, url):
# We need a key file for the client, but as soon as the client is
# created, we don't need it any more. Then create a new client and
# add it to our cadre of clients to use
keystring = pybitcointools.encode_privkey(
pybitcointools.random_key(), 'wif')
self._clients.append(IntegerKeyClient(
baseurl=url,
keystring=keystring))
def get_wif_privkey(self, pw):
if not self.is_wallet_loaded:
raise Exception('Tried getting private key when wallet not loaded.')
prv = ''
try:
prv = wallet.decrypt_privkey(self.encr_privkey, pw)
except:
raise PasswordError("Wrong password!")
frm = bc.get_privkey_format(prv)
if frm == 'hex':
wif_privkey = bc.encode_privkey(prv, 'wif', self.magic_byte)
elif frm == 'hex_compressed':
wif_privkey = bc.encode_privkey(prv, 'wif_compressed', self.magic_byte)
else:
raise Exception('Unrecognized private key format: ' + frm)
return wif_privkey
def load_config():
home = os.path.expanduser("~")
real_user = getpass.getuser()
config_file = os.path.join(home, ".sawtooth", "libor.cfg")
key_dir = os.path.join(home, ".sawtooth", "keys")
config = ConfigParser.SafeConfigParser()
config.set('DEFAULT', 'url', 'http://localhost:8800')
config.set('DEFAULT', 'key_dir', key_dir)
config.set('DEFAULT', 'key_file', '%(key_dir)s/%(username)s.wif')
config.set('DEFAULT', 'username', real_user)
# If we already have a config file, then read it. Otherwise,
# we are going to write a default one.
if os.path.exists(config_file):
config.read(config_file)
else:
if not os.path.exists(os.path.dirname(config_file)):
os.makedirs(os.path.dirname(config_file))
with open("{}.new".format(config_file), "w") as fd:
config.write(fd)
os.rename("{}.new".format(config_file), config_file)
# If the key file does not already exist, then we are going
# to generate one
wif_filename = config.get('DEFAULT', 'key_file')
if wif_filename.endswith(".wif"):
addr_filename = wif_filename[0:-len(".wif")] + ".addr"
else:
addr_filename = wif_filename + ".addr"
if not os.path.exists(wif_filename):
try:
if not os.path.exists(os.path.dirname(wif_filename)):
os.makedirs(os.path.dirname(wif_filename))
private_key = pybitcointools.random_key()
encoded_key = pybitcointools.encode_privkey(private_key, 'wif')
addr = pybitcointools.privtoaddr(private_key)
with open(wif_filename, "w") as wif_fd:
wif_fd.write(encoded_key)
wif_fd.write("\n")
with open(addr_filename, "w") as addr_fd:
addr_fd.write(addr)
addr_fd.write("\n")
except IOError as ioe:
raise LIBORClientException("IOError: {}".format(str(ioe)))
return config
def test_pbt_match(self):
"""
Tests matching results between pybitcointools and native
ECDSA key recovery
"""
# This key has a small public key value which tests padding
wifstr = '5JtMb6tmM9vT6QHyM7RR8pjMViqccukgMFNCPvG5xhLVf6CMoGx'
priv = pbt.encode_privkey(pbt.decode_privkey(wifstr, 'wif'), 'hex')
msg = 'foo'
sig = pbt.ecdsa_sign(msg, priv)
native_recovered = pbct_nativerecover.recover_pubkey(msg, sig)
py_recovered = pbt.ecdsa_recover(msg, sig)
self.assertEquals(native_recovered, py_recovered)
def bytes_to_xes(b: bytes) -> Tuple[Scalar, Scalar, Scalar, Scalar]:
"""
Convinient function
Converts bytes to a scalar (x), and calculates
x, x^2, inv(x), and inv(x^2)
"""
x: Scalar = B.encode_privkey(b, 'decimal') % B.N
x_sq: Scalar = pow(x, 2, B.N)
xinv: Scalar = modinv(x, B.N)
xinv_sq: Scalar = pow(xinv, 2, B.N)
return (x, x_sq, xinv, xinv_sq)
def do_init(args, config):
username = config.get('DEFAULT', 'username')
if args.username is not None:
if len(args.username) < 3 or len(args.username) > 16:
raise ClientException(
"username must be between 3 and 16 characters")
username = args.username
config.set('DEFAULT', 'username', username)
print "set username: {}".format(username)
else:
print "Username: {}".format(username)
http_url = config.get('DEFAULT', 'url')
if args.url is not None:
http_url = args.url
config.set('DEFAULT', 'url', http_url)
print "set url to {}".format(http_url)
else:
print "Validator url: {}".format(http_url)
save_config(config)
wif_filename = config.get('DEFAULT', 'key_file')
if wif_filename.endswith(".wif"):
addr_filename = wif_filename[0:-len(".wif")] + ".addr"
else:
addr_filename = wif_filename + ".addr"
if not os.path.exists(wif_filename):
try:
if not os.path.exists(os.path.dirname(wif_filename)):
os.makedirs(os.path.dirname(wif_filename))
privkey = pybitcointools.random_key()
encoded = pybitcointools.encode_privkey(privkey, 'wif')
addr = pybitcointools.privtoaddr(privkey)
with open(wif_filename, "w") as wif_fd:
print "writing file: {}".format(wif_filename)
wif_fd.write(encoded)
wif_fd.write("\n")
with open(addr_filename, "w") as addr_fd:
print "writing file: {}".format(addr_filename)
addr_fd.write(addr)
addr_fd.write("\n")
except IOError, ioe:
raise ClientException("IOError: {}".format(str(ioe)))
def on_validator_discovered(self, url):
# We need a key file for the client, but as soon as the client is
# created, we don't need it any more, so a temporary file is
# sufficient
key_file = NamedTemporaryFile()
private_key = pybitcointools.random_key()
encoded_key = pybitcointools.encode_privkey(private_key, 'wif')
key_file.write(encoded_key)
key_file.write('\n')
key_file.flush()
# Create a new client and add it to our cadre of clients to use
self._clients.append(XoClient(url, key_file.name))
# Closing the temporary file will cause it to also be deleted
key_file.close()
def test_compressed_keys(self):
"""
Tests compressed key
"""
msg = 'foo'
priv = pbt.encode_privkey(pbt.random_key(), 'hex_compressed')
sig = pbt.ecdsa_sign(msg, priv)
# Force old pybitcointools to behave
v, r, s = pbt.decode_sig(sig)
if v < 31:
v += 4
sig = pbt.encode_sig(v, r, s)
pub = pbt.compress(pbt.privtopub(priv))
native_recovered = pbct_nativerecover.recover_pubkey(msg, sig)
self.assertEquals(native_recovered, pub,
"Priv Key that failed: {}".format(priv))
def _create_temporary_key_file():
"""
A useful helper method for derived classes. Remember to close the
returned temporary file so that it gets deleted.
Returns:
A NamedTemporaryFile object.
"""
key_file = NamedTemporaryFile()
private_key = pybitcointools.random_key()
encoded_key = pybitcointools.encode_privkey(private_key, 'wif')
key_file.write(encoded_key)
key_file.write('\n')
key_file.flush()
return key_file
def test_compressed_keys(self):
"""
Tests compressed key
"""
msg = 'foo'
self.longMessage = True
priv = pbt.encode_privkey(pbt.random_key(), 'hex_compressed')
sig = pbt.ecdsa_sign(msg, priv)
# Force old pybitcointools to behave
v, r, s = pbt.decode_sig(sig)
if v < 31:
v += 4
sig = pbt.encode_sig(v, r, s)
pub = pbt.compress(pbt.privtopub(priv))
native_recovered = gossip.signed_object.get_verifying_key(msg, sig)
self.assertEquals(native_recovered, pub,
"Priv Key that failed: {}".format(priv))
def test_compressed_keys(self):
"""
Tests compressed key
"""
msg = 'foo'
self.longMessage = True
priv = pbt.encode_privkey(pbt.random_key(), 'hex_compressed')
sig = pbt.ecdsa_sign(msg, priv)
# Force old pybitcointools to behave
v, r, s = pbt.decode_sig(sig)
if v < 31:
v += 4
sig = pbt.encode_sig(v, r, s)
pub = pbt.compress(pbt.privtopub(priv))
native_recovered = gossip.signed_object.get_verifying_key(msg, sig)
self.assertEquals(native_recovered, pub,
"Priv Key that failed: {}".format(priv))
def __init__(self, private_key=None, compressed=False):
""" Takes in a private key/secret exponent.
"""
self._compressed = compressed
if not private_key:
secret_exponent = random_secret_exponent(self._curve.order)
else:
secret_exponent = encode_privkey(private_key, 'decimal')
if get_privkey_format(private_key).endswith('compressed'):
self._compressed = True
# make sure that: 1 <= secret_exponent < curve_order
if not is_secret_exponent(secret_exponent, self._curve.order):
raise IndexError(_errors["EXPONENT_OUTSIDE_CURVE_ORDER"])
self._ecdsa_private_key = ecdsa.keys.SigningKey.from_secret_exponent(
secret_exponent, self._curve, self._hash_function
)
def setup(self):
self.state = mktplace_state.MarketPlaceState(self.urls[0])
with Progress("Creating participants") as p:
for i in range(0, self.count):
name = "actor-{}".format(i)
keyfile = os.path.join(self.testDir, "{}.wif".format(name))
if os.path.exists(keyfile):
key = read_key_file(keyfile)
else:
key = pybitcointools.encode_privkey(
pybitcointools.random_key(), 'wif')
write_key_file(keyfile, key)
url = self.urls[random.randint(0, len(self.urls) - 1)]
a = MktActor(name, url, key)
self.Actors.append(a)
p.step()
with Progress("Registering actors assets") as p:
for a in self.Actors:
# create assets
a.register_asset(a.Name + "-asset")
p.step()
self.wait_for_transaction_commits()
with Progress("Registering holdings") as p:
for a in self.Actors:
a.update()
a.offers = []
for a2 in self.Actors:
count = 0
if a is a2:
# for each iteration we need 1 to pay with and 1 to
# give
count = 2 * self.count * self.iterations
for ast in a2.assets.keys():
a.register_holding(ast, count)
p.step()
self.wait_for_transaction_commits()
def create_signup_info(cls, originator_public_key):
# First we need to create a public/private key pair for the PoET
# enclave to use.
cls._poet_private_key = pybitcointools.random_key()
cls._poet_public_key = pybitcointools.privtopub(cls._poet_private_key)
cls._active_wait_timer = None
# We are going to fake out the sealing the signup data.
signup_data = {
'poet_public_key':
pybitcointools.encode_pubkey(cls._poet_public_key, 'hex'),
'poet_private_key':
pybitcointools.encode_privkey(cls._poet_private_key, 'hex')
}
sealed_signup_data = \
pybitcointools.base64.b32encode(dict2json(signup_data))
# Create a fake report
report_data = {
'originator_public_key_hash':
pybitcointools.sha256(
pybitcointools.encode_pubkey(originator_public_key, 'hex')),
'poet_public_key':
pybitcointools.encode_pubkey(cls._poet_public_key, 'hex')
}
report = {'report_data': pybitcointools.sha256(dict2json(report_data))}
report = pybitcointools.base64.b32encode(dict2json(report))
# Fake our "proof" data.
proof_data = {
'attestation_evidence_payload':
pybitcointools.sha256(report),
'attestation_verification_report':
pybitcointools.sha256('Shave and a haircut...Two bits!')
}
return \
EnclaveSignupInfo(
anti_sybil_id='Sally Field',
poet_public_key=signup_data['poet_public_key'],
proof_data=proof_data,
sealed_signup_data=sealed_signup_data)
def setup(self):
self.state = mktplace_state.MarketPlaceState(self.urls[0])
with Progress("Creating participants") as p:
for i in range(0, self.count):
name = "actor-{}".format(i)
keyfile = os.path.join(self.testDir, "{}.wif".format(name))
if os.path.exists(keyfile):
key = read_key_file(keyfile)
else:
key = pybitcointools.encode_privkey(
pybitcointools.random_key(), 'wif')
write_key_file(keyfile, key)
url = self.urls[random.randint(0, len(self.urls) - 1)]
a = MktActor(name, url, key)
self.Actors.append(a)
p.step()
with Progress("Registering actors assets") as p:
for a in self.Actors:
# create assets
a.register_asset(a.Name + "-asset")
p.step()
self.wait_for_transaction_commits()
with Progress("Registering holdings") as p:
for a in self.Actors:
a.update()
a.offers = []
for a2 in self.Actors:
count = 0
if a is a2:
# for each iteration we need 1 to pay with and 1 to
# give
count = 2 * self.count * self.iterations
for ast in a2.assets.keys():
a.register_holding(ast, count)
p.step()
self.wait_for_transaction_commits()
def _decode_privkey(encoded_privkey, encoding_format='wif'):
"""
Args:
encoded_privkey: an encoded private key string
encoding_format: string indicating format such as 'wif'
Returns:
private key object useable with this module
"""
if encoding_format == 'wif':
# base58 to int
priv = pybitcointools.decode_privkey(encoded_privkey, encoding_format)
# int to hex string
priv = pybitcointools.encode_privkey(priv, 'hex')
# hex string to bytes
try: # check python 3
priv = priv.to_bytes(32, byteorder='big')
except AttributeError:
priv = binascii.unhexlify(priv)
else:
raise TypeError("unsupported private key format")
return secp256k1.PrivateKey(priv)
def do_init(args, config):
username = config.get('DEFAULT', 'username')
if args.username is not None:
username = args.username
config.set('DEFAULT', 'username', username)
print "set username: {}".format(username)
save_config(config)
wif_filename = config.get('DEFAULT', 'key_file')
if wif_filename.endswith(".wif"):
addr_filename = wif_filename[0:-len(".wif")] + ".addr"
else:
addr_filename = wif_filename + ".addr"
if not os.path.exists(wif_filename):
try:
if not os.path.exists(os.path.dirname(wif_filename)):
os.makedirs(os.path.dirname(wif_filename))
privkey = pybitcointools.random_key()
encoded = pybitcointools.encode_privkey(privkey, 'wif')
addr = pybitcointools.privtoaddr(privkey)
with open(wif_filename, "w") as wif_fd:
print "writing file: {}".format(wif_filename)
wif_fd.write(encoded)
wif_fd.write("\n")
with open(addr_filename, "w") as addr_fd:
print "writing file: {}".format(addr_filename)
addr_fd.write(addr)
addr_fd.write("\n")
except IOError, ioe:
raise XoException("IOError: {}".format(str(ioe)))
import pybitcointools
import sys
if __name__ == "__main__":
if len(sys.argv) >= 2:
priv_key = sys.argv[
1] #"LmB72UZvRmJ5cUPZWpxqYWW5KkCgASa53GZQNhWNTPzJ9J1R4T8x"
priv_data = pybitcointools.decode_privkey(priv_key)
print(pybitcointools.encode_privkey(priv_data, "wif_compressed"))
print(pybitcointools.privtoaddr(priv_key))
else:
print("Usage: %s [private_key]" % sys.argv[0])
def main(args=sys.argv[1:]):
parser = argparse.ArgumentParser()
# The intent is that node_name and keydir both be optional at some
# future point, by reading in the appropriate values from the config
# file. Therefore, no default is currently set and both are marked
# as required so that the future usage of using config values as
# defaults can be added without breaking anything.
parser.add_argument('node_name', help="name of the node")
parser.add_argument('--keydir',
help="directory to write key files",
required=True)
parser.add_argument('-f',
'--force',
help="overwrite files if they exist",
action='store_true')
parser.add_argument('-q',
'--quiet',
help="print no output",
action='store_true')
options = parser.parse_args(args)
base_filename = os.path.join(options.keydir, options.node_name)
wif_filename = base_filename + ".wif"
addr_filename = base_filename + ".addr"
if not os.path.isdir(options.keydir):
print >> sys.stderr, "no such directory: {}".format(options.keydir)
sys.exit(1)
if not options.force:
file_exists = False
for filename in [wif_filename, addr_filename]:
if os.path.exists(filename):
file_exists = True
print >> sys.stderr, "file exists: {}".format(filename)
if file_exists:
print >> sys.stderr, \
"rerun with --force to overwrite existing files"
sys.exit(1)
privkey = pybitcointools.random_key()
encoded = pybitcointools.encode_privkey(privkey, 'wif')
addr = pybitcointools.privtoaddr(privkey)
try:
wif_exists = os.path.exists(wif_filename)
with open(wif_filename, "w") as wif_fd:
if not options.quiet:
if wif_exists:
print "overwriting file: {}".format(wif_filename)
else:
print "writing file: {}".format(wif_filename)
wif_fd.write(encoded)
wif_fd.write("\n")
addr_exists = os.path.exists(addr_filename)
with open(addr_filename, "w") as addr_fd:
if not options.quiet:
if addr_exists:
print "overwriting file: {}".format(addr_filename)
else:
print "writing file: {}".format(addr_filename)
addr_fd.write(addr)
addr_fd.write("\n")
except IOError, ioe:
print >> sys.stderr, "IOError: {}".format(str(ioe))
sys.exit(1)
from __future__ import print_function
import pybitcointools
# Generate a random private key
valid_private_key = False
while not valid_private_key:
private_key = pybitcointools.random_key()
decoded_private_key = pybitcointools.decode_privkey(private_key, 'hex')
valid_private_key = 0 < decoded_private_key < pybitcointools.N
print("Private Key (hex) is: ", private_key)
print("Private Key (decimal) is: ", decoded_private_key)
# Convert private key to WIF format
wif_encoded_private_key = pybitcointools.encode_privkey(
decoded_private_key, 'wif')
print("Private Key (WIF) is: ", wif_encoded_private_key)
# Add suffix "01" to indicate a compressed private key
compressed_private_key = private_key + '01'
print("Private Key Compressed (hex) is: ", compressed_private_key)
# Generate a WIF format from the compressed private key (WIF-compressed)
wif_compressed_private_key = pybitcointools.encode_privkey(
pybitcointools.decode_privkey(compressed_private_key, 'hex'),
'wif_compressed')
print("Private Key (WIF-Compressed) is: ", wif_compressed_private_key)
# Multiply the EC generator point G with the private key to get a public key point
public_key = pybitcointools.fast_multiply(pybitcointools.G,
decoded_private_key)
def setUp(self):
self.brainwallet_string = 'Here is a brainwallet string for testing purposes'
self.private_key = bc.sha256(self.brainwallet_string)
self.private_key_wif = bc.encode_privkey(self.private_key, 'wif')
self.addr = bc.privkey_to_address(self.private_key)
import pybitcointools
# Generate a random private key
valid_private_key = False
while not valid_private_key:
private_key = pybitcointools.random_key()
decoded_private_key = pybitcointools.decode_privkey(private_key, 'hex')
valid_private_key = 0 < decoded_private_key < pybitcointools.N
print "Private Key (hex) is:", private_key
print "Private Key (decimal) is:", decoded_private_key
# Convert private key to WIF format
wif_encoded_private_key = pybitcointools.encode_privkey(
decoded_private_key, 'wif')
print "Private Key (WIF) is:", wif_encoded_private_key
# Add suffix "01" to indicate a compressed private key
compressed_private_key = private_key + '01'
print "Private Key Compressed (hex) is:", compressed_private_key
# Generate a WIF format from the compressed private key (WIF-)
def setUp(self):
self.brainwallet_string = 'Here is a brainwallet string for testing purposes'
self.private_key = bc.sha256(self.brainwallet_string)
self.private_key_wif = bc.encode_privkey(self.private_key, 'wif')
self.addr = bc.privkey_to_address(self.private_key)
def to_bin(self):
if self._compressed:
return encode_privkey(
self._ecdsa_private_key.to_string(), 'bin_compressed')
else:
return self._ecdsa_private_key.to_string()
def generate_private_key():
return pybitcointools.encode_privkey(pybitcointools.random_key(), 'wif')
def to_hex(self):
if self._compressed:
return encode_privkey(
self._ecdsa_private_key.to_string(), 'hex_compressed')
else:
return hexlify(self.to_bin())
def create_signup_info(cls,
originator_public_key,
validator_network_basename,
most_recent_wait_certificate_id):
with cls._lock:
# First we need to create a public/private key pair for the PoET
# enclave to use.
cls._poet_private_key = pybitcointools.random_key()
cls._poet_public_key = \
pybitcointools.privtopub(cls._poet_private_key)
cls._active_wait_timer = None
# We are going to fake out the sealing the signup data.
signup_data = {
'poet_public_key':
pybitcointools.encode_pubkey(cls._poet_public_key, 'hex'),
'poet_private_key':
pybitcointools.encode_privkey(
cls._poet_private_key,
'hex')
}
sealed_signup_data = \
pybitcointools.base64.b32encode(dict2json(signup_data))
# Create a fake report
report_data = {
'originator_public_key_hash':
pybitcointools.sha256(
pybitcointools.encode_pubkey(
originator_public_key,
'hex')),
'poet_public_key':
pybitcointools.encode_pubkey(cls._poet_public_key, 'hex')
}
report = {
'report_data': pybitcointools.sha256(dict2json(report_data)),
'validator_network_basename': validator_network_basename
}
# Fake our "proof" data.
attestation_evidence_payload = {
'enclave_quote':
pybitcointools.base64.b64encode(dict2json(report)),
'pse_manifest':
pybitcointools.base64.b64encode(
pybitcointools.sha256(
'manifest destiny')),
'nonce': most_recent_wait_certificate_id
}
attestation_verification_report = {
'attestation_evidence_payload': attestation_evidence_payload,
'anti_sybil_id': cls._anti_sybil_id
}
proof_data = {
'attestation_verification_report':
attestation_verification_report,
'signature':
pybitcointools.ecdsa_sign(
dict2json(attestation_verification_report),
cls._report_private_key)
}
return \
EnclaveSignupInfo(
poet_public_key=signup_data['poet_public_key'],
proof_data=proof_data,
sealed_signup_data=sealed_signup_data)
def encode_privkey(privkey, encoding_format='wif'):
return pybitcointools.encode_privkey(privkey, encoding_format)
def generate_private_key():
return pybitcointools.encode_privkey(pybitcointools.random_key(), 'wif')
def privkey_to_wif(self):
return pybitcointools.encode_privkey(self.to_btc_privkey(), "wif")
wif_filename = os.path.join(key_dir, key_name + '.wif')
addr_filename = os.path.join(key_dir, key_name + '.addr')
if not args.force:
file_exists = False
for filename in [wif_filename, addr_filename]:
if os.path.exists(filename):
file_exists = True
print >> sys.stderr, 'file exists: {}'.format(filename)
if file_exists:
raise ClientException(
'files exist, rerun with --force to overwrite existing files')
privkey = pybitcointools.random_key()
encoded = pybitcointools.encode_privkey(privkey, 'wif')
addr = pybitcointools.privtoaddr(privkey)
try:
wif_exists = os.path.exists(wif_filename)
with open(wif_filename, 'w') as wif_fd:
if not args.quiet:
if wif_exists:
print 'overwriting file: {}'.format(wif_filename)
else:
print 'writing file: {}'.format(wif_filename)
wif_fd.write(encoded)
wif_fd.write('\n')
addr_exists = os.path.exists(addr_filename)
with open(addr_filename, 'w') as addr_fd:
wif_filename = os.path.join(key_dir, key_name + '.wif')
addr_filename = os.path.join(key_dir, key_name + '.addr')
if not args.force:
file_exists = False
for filename in [wif_filename, addr_filename]:
if os.path.exists(filename):
file_exists = True
print >>sys.stderr, 'file exists: {}'.format(filename)
if file_exists:
raise ClientException(
'files exist, rerun with --force to overwrite existing files')
privkey = pybitcointools.random_key()
encoded = pybitcointools.encode_privkey(privkey, 'wif')
addr = pybitcointools.privtoaddr(privkey)
try:
wif_exists = os.path.exists(wif_filename)
with open(wif_filename, 'w') as wif_fd:
if not args.quiet:
if wif_exists:
print 'overwriting file: {}'.format(wif_filename)
else:
print 'writing file: {}'.format(wif_filename)
wif_fd.write(encoded)
wif_fd.write('\n')
addr_exists = os.path.exists(addr_filename)
with open(addr_filename, 'w') as addr_fd:
def get_blinding_value() -> Scalar:
return B.encode_privkey(os.urandom(32), 'decimal')
