def create_wait_timer(cls, previous_certificate_id, local_mean):
# Create some value from the cert ID. We are just going to use
# the seal key to sign the cert ID. We will then use the low-order
# 64 bits to change that to a number [0, 1]
tag = \
pybitcointools.base64.b64decode(
pybitcointools.ecdsa_sign(
previous_certificate_id,
cls._seal_private_key))
tagd = float(struct.unpack('L', tag[-8:])[0]) / (2**64 - 1)
# Now compute the duration
duration = cls.__MINIMUM_DURATTION - local_mean * math.log(tagd)
# Create and sign the wait timer
wait_timer = \
EnclaveWaitTimer(
duration=duration,
previous_certificate_id=previous_certificate_id,
local_mean=local_mean)
wait_timer.signature = \
pybitcointools.ecdsa_sign(
wait_timer.serialize(),
cls._poet_private_key)
# Keep track of the active wait timer
cls._active_wait_timer = wait_timer
return wait_timer
def sign_message_with_transaction(transaction, key):
"""
Signs a transaction message or transaction
:param transaction dict:
:param key str: A signing key
returns message, txnid tuple: The first 16 characters
of a sha256 hexdigest.
"""
transaction['Nonce'] = time.time()
pub = pybitcointools.encode_pubkey(pybitcointools.privkey_to_pubkey(key),
"hex")
transaction["public_key"] = pub
sig = pybitcointools.ecdsa_sign(
dict2cbor(transaction),
key
)
transaction['Signature'] = sig
txnid = hashlib.sha256(transaction['Signature']).hexdigest()[:16]
message = {
'Transaction': transaction,
'__TYPE__': "/mktplace.transactions.MarketPlace/Transaction",
'__NONCE__': time.time(),
}
cbor_serialized_mess = dict2cbor(message)
signature = pybitcointools.ecdsa_sign(
cbor_serialized_mess,
key
)
message['__SIGNATURE__'] = signature
return message, txnid
def _sign_message_with_transaction(transaction, message_type, key):
"""
Signs a transaction message or transaction
:param transaction (dict):
:param key (str): A signing key
returns message, txnid (tuple): The first 16 characters
of a sha256 hexdigest.
"""
transaction['Nonce'] = time.time()
pub = pybitcointools.encode_pubkey(pybitcointools.privkey_to_pubkey(key),
"hex")
transaction["public_key"] = pub
sig = pybitcointools.ecdsa_sign(_dict2cbor(transaction), key)
transaction['Signature'] = sig
txnid = hashlib.sha256(transaction['Signature']).hexdigest()[:16]
message = {
'Transaction': transaction,
'__TYPE__': message_type,
'__NONCE__': time.time(),
}
cbor_serialized_message = _dict2cbor(message)
signature = pybitcointools.ecdsa_sign(cbor_serialized_message, key)
message['__SIGNATURE__'] = signature
return message, txnid
def create_intkey_transaction(verb, name, value, private_key, public_key):
payload = IntKeyPayload(
verb=verb, name=name, value=value)
# The prefix should eventually be looked up from the
# validator's namespace registry.
intkey_prefix = hashlib.sha512('intkey').hexdigest()[0:6]
addr = intkey_prefix + hashlib.sha512(name).hexdigest()
header = transaction_pb2.TransactionHeader(
signer=public_key,
family_name='intkey',
family_version='1.0',
inputs=[addr],
outputs=[addr],
dependencies=[],
payload_encoding="application/cbor",
payload_sha512=payload.sha512(),
batcher=public_key)
header_bytes = header.SerializeToString()
signature = pybitcointools.ecdsa_sign(
header_bytes,
private_key)
transaction = transaction_pb2.Transaction(
header=header_bytes,
payload=payload.to_cbor(),
signature=signature)
return transaction
def test_deserialized_wait_timer(self):
wait_timer = \
EnclaveWaitTimer(
duration=3.14159,
previous_certificate_id='Bond. James Bond.',
local_mean=2.71828)
serialized = wait_timer.serialize()
signing_key = self._create_random_key()
wait_timer.signature = \
pybitcointools.ecdsa_sign(serialized, signing_key)
copy_wait_timer = \
EnclaveWaitTimer.wait_timer_from_serialized(
serialized,
wait_timer.signature)
self.assertAlmostEquals(
wait_timer.request_time,
copy_wait_timer.request_time)
self.assertAlmostEquals(
wait_timer.duration,
copy_wait_timer.duration)
self.assertEqual(
wait_timer.previous_certificate_id,
copy_wait_timer.previous_certificate_id)
self.assertAlmostEquals(
wait_timer.local_mean,
copy_wait_timer.local_mean)
self.assertEqual(
wait_timer.signature,
copy_wait_timer.signature)
self.assertEqual(serialized, copy_wait_timer.serialize())
def test_deserialized_wait_timer(self):
wait_timer = \
EnclaveWaitTimer(
duration=3.14159,
previous_certificate_id='Bond. James Bond.',
local_mean=2.71828)
serialized = wait_timer.serialize()
signing_key = self._create_random_key()
wait_timer.signature = \
pybitcointools.ecdsa_sign(serialized, signing_key)
copy_wait_timer = \
EnclaveWaitTimer.wait_timer_from_serialized(
serialized,
wait_timer.signature)
self.assertAlmostEquals(wait_timer.request_time,
copy_wait_timer.request_time)
self.assertAlmostEquals(wait_timer.duration, copy_wait_timer.duration)
self.assertEqual(wait_timer.previous_certificate_id,
copy_wait_timer.previous_certificate_id)
self.assertAlmostEquals(wait_timer.local_mean,
copy_wait_timer.local_mean)
self.assertEqual(wait_timer.signature, copy_wait_timer.signature)
self.assertEqual(serialized, copy_wait_timer.serialize())
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 easy_add_transaction(tx_orig, sign_over, privkey):
state=state_library.current_state()
pubkey=pt.privtopub(privkey)
if pubkey not in state or 'count' not in state[pubkey]:
my_count=1
else:
my_count=state[pubkey]['count']
txs=blockchain.load_transactions()
my_txs=filter(lambda x: x['id']==pubkey, txs)
tx=copy.deepcopy(tx_orig)
tx['count']=len(my_txs)+my_count
tx['signature']=pt.ecdsa_sign(blockchain.message2signObject(tx, sign_over), privkey)
print(blockchain.add_transaction(tx))
if 'move_number' in tx:
for i in range(10):
tx['move_number']+=1
tx['signature']=pt.ecdsa_sign(blockchain.message2signObject(tx, sign_over), privkey)
print(blockchain.add_transaction(tx))
print('tx: ' +str(tx))
blockchain.pushtx(tx, config.peers_list)
def easy_add_transaction(tx_orig, sign_over, privkey):
state = state_library.current_state()
pubkey = pt.privtopub(privkey)
if pubkey not in state or "count" not in state[pubkey]:
my_count = 1
else:
my_count = state[pubkey]["count"]
txs = blockchain.load_transactions()
my_txs = filter(lambda x: x["id"] == pubkey, txs)
tx = copy.deepcopy(tx_orig)
tx["count"] = len(my_txs) + my_count
tx["signature"] = pt.ecdsa_sign(blockchain.message2signObject(tx, sign_over), privkey)
print (blockchain.add_transaction(tx))
if "move_number" in tx:
for i in range(10):
tx["move_number"] += 1
tx["signature"] = pt.ecdsa_sign(blockchain.message2signObject(tx, sign_over), privkey)
print (blockchain.add_transaction(tx))
print ("tx: " + str(tx))
blockchain.pushtx(tx, quick_mine.peers_list)
def test_bulk_keymatch(self):
"""
Tests key recovery over several keys
"""
msg = 'foo'
for _ in range(0, 20):
priv = pbt.random_key()
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,
"Priv Key that failed: {}".format(priv))
def create_wait_timer(cls, previous_certificate_id, local_mean):
with cls._lock:
# If we don't have a PoET private key, then the enclave has not
# been properly initialized (either by calling create_signup_info
# or unseal_signup_data)
if cls._poet_private_key is None:
raise \
WaitTimerError(
'Enclave must be initialized before attempting to '
'create a wait timer')
# Create some value from the cert ID. We are just going to use
# the seal key to sign the cert ID. We will then use the
# low-order 64 bits to change that to a number [0, 1]
tag = \
pybitcointools.base64.b64decode(
pybitcointools.ecdsa_sign(
previous_certificate_id,
cls._seal_private_key))
tagd = float(struct.unpack('L', tag[-8:])[0]) / (2**64 - 1)
# Now compute the duration
duration = cls.__MINIMUM_DURATTION - local_mean * math.log(tagd)
# Create and sign the wait timer
wait_timer = \
EnclaveWaitTimer(
duration=duration,
previous_certificate_id=previous_certificate_id,
local_mean=local_mean)
wait_timer.signature = \
pybitcointools.ecdsa_sign(
wait_timer.serialize(),
cls._poet_private_key)
# Keep track of the active wait timer
cls._active_wait_timer = wait_timer
return wait_timer
def test_bulk_keymatch(self):
"""
Tests key recovery over several keys
"""
msg = 'foo'
self.longMessage = True
for x in range(0, 20):
priv = pbt.random_key()
sig = pbt.ecdsa_sign(msg, priv)
native_recovered = gossip.signed_object.get_verifying_key(msg, sig)
py_recovered = pbt.ecdsa_recover(msg, sig)
self.assertEquals(native_recovered, py_recovered,
"Priv Key that failed: {}".format(priv))
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.decode_privkey(wifstr, 'wif')
msg = 'foo'
sig = pbt.ecdsa_sign(msg, priv)
native_recovered = gossip.signed_object.get_verifying_key(msg, sig)
py_recovered = pbt.ecdsa_recover(msg, sig)
self.assertEquals(native_recovered, py_recovered)
def test_bulk_keymatch(self):
"""
Tests key recovery over several keys
"""
msg = 'foo'
self.longMessage = True
for x in range(0, 20):
priv = pbt.random_key()
sig = pbt.ecdsa_sign(msg, priv)
native_recovered = gossip.signed_object.get_verifying_key(msg, sig)
py_recovered = pbt.ecdsa_recover(msg, sig)
self.assertEquals(native_recovered, py_recovered,
"Priv Key that failed: {}".format(priv))
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.decode_privkey(wifstr, 'wif')
msg = 'foo'
sig = pbt.ecdsa_sign(msg, priv)
native_recovered = gossip.signed_object.get_verifying_key(msg, sig)
py_recovered = pbt.ecdsa_recover(msg, sig)
self.assertEquals(native_recovered, py_recovered)
def easy_add_transaction(tx_orig, sign_over, privkey, state):
tx=copy.deepcopy(tx_orig)
pubkey=pt.privtopub(privkey)
if pubkey not in state or 'count' not in state[pubkey]:
tx['count']=1
else:
tx['count']=state[pubkey]['count']
txs=blockchain.load_transactions()
my_txs=filter(lambda x: x['id']==pubkey, txs)
tx['signature']=pt.ecdsa_sign(blockchain.message2signObject(tx, sign_over), privkey)
if blockchain.add_transaction(tx):
blockchain.pushtx(tx, config.peers_list)
return True
if 'move_number' in tx:
for i in range(10):
tx['move_number']+=1
tx['signature']=pt.ecdsa_sign(blockchain.message2signObject(tx, sign_over), privkey)
if blockchain.add_transaction(tx):
blockchain.pushtx(tx, config.peers_list)
return True
print('SOMETHING IS BROKEN')
return False
def sign_message_with_transaction(transaction, key):
"""
Signs a transaction message or transaction
:param transaction dict:
:param key str: A signing key
returns message, txnid tuple: The first 16 characters
of a sha256 hexdigest.
"""
transaction['Nonce'] = time.time()
sig = pybitcointools.ecdsa_sign(dict2cbor(transaction), key)
transaction['Signature'] = sig
txnid = hashlib.sha256(transaction['Signature']).hexdigest()[:16]
message = {
'Transaction': transaction,
'__TYPE__': "/mktplace.transactions.MarketPlace/Transaction",
'__NONCE__': time.time(),
}
cbor_serialized_mess = dict2cbor(message)
signature = pybitcointools.ecdsa_sign(cbor_serialized_mess, key)
message['__SIGNATURE__'] = signature
return message, txnid
def sign_object(self, signingkey):
"""Generates a string signature for the object using the signing
key.
Args:
signingkey (str): hex encoded private key
"""
self._originator_id = None
serialized = self.serialize(signable=True)
self.Signature = pybitcointools.ecdsa_sign(serialized, signingkey)
self._recover_verifying_address()
self._identifier = hashlib.sha256(self.Signature).hexdigest()
def sign_object(self, signingkey):
"""Generates a string signature for the object using the signing
key.
Args:
signingkey (str): hex encoded private key
"""
self._originator_id = None
serialized = self.serialize(signable=True)
self.Signature = pybitcointools.ecdsa_sign(serialized, signingkey)
self._recover_verifying_address()
self._identifier = hashlib.sha256(self.Signature).hexdigest()
def create_jvm_sc_transaction(verb,
private_key,
public_key,
bytecode=None,
methods=None,
byte_addr=None,
method=None,
parameters=None,
addresses=None):
payload = JVM_SC_Payload(verb=verb,
bytecode=bytecode,
methods=methods,
byte_addr=byte_addr,
method=method,
parameters=parameters)
if addresses is None:
addresses = []
# The prefix should eventually be looked up from the
# validator's namespace registry.
if byte_addr is not None:
addr = byte_addr
elif bytecode is not None:
addr = get_address('jvm_sc', bytecode)
else:
raise Exception
addresses.append(addr)
header = transaction_pb2.TransactionHeader(
signer=public_key,
family_name='jvm_sc',
family_version='1.0',
inputs=addresses,
outputs=addresses,
dependencies=[],
payload_encoding="application/protobuf",
payload_sha512=payload.sha512(),
batcher=public_key)
header_bytes = header.SerializeToString()
signature = pybitcointools.ecdsa_sign(header_bytes, private_key)
transaction = transaction_pb2.Transaction(header=header_bytes,
payload=payload.payload_bytes,
signature=signature)
return transaction
def create_wait_certificate(cls, timer, block_digest):
# TO DO - implement PoET 1 create certificate logic
# First create a new enclave wait certificate using the data provided
# and then sign the certificate with the PoET private key
wait_certificate = \
EnclaveWaitCertificate.wait_certificate_with_timer(
timer=timer,
block_digest=block_digest)
wait_certificate.signature = \
pybitcointools.ecdsa_sign(
wait_certificate.serialize(),
cls._poet_private_key)
return wait_certificate
def easy_add_transaction(tx_orig, sign_over, privkey, state):
tx = copy.deepcopy(tx_orig)
pubkey = pt.privtopub(privkey)
if pubkey not in state or 'count' not in state[pubkey]:
tx['count'] = 1
else:
tx['count'] = state[pubkey]['count']
txs = blockchain.load_transactions()
my_txs = filter(lambda x: x['id'] == pubkey, txs)
tx['signature'] = pt.ecdsa_sign(go.message2signObject(tx, sign_over),
privkey)
if blockchain.add_transaction(tx):
blockchain.pushtx(tx, config.peers_list)
return True
if 'move_number' in tx:
for i in range(10):
tx['move_number'] += 1
tx['signature'] = pt.ecdsa_sign(
go.message2signObject(tx, sign_over), privkey)
if blockchain.add_transaction(tx):
blockchain.pushtx(tx, config.peers_list)
return True
print('SOMETHING IS BROKEN')
return False
def create_batch(transactions, private_key, public_key):
transaction_signatures = [t.signature for t in transactions]
header = batch_pb2.BatchHeader(
signer=public_key, transaction_signatures=transaction_signatures)
header_bytes = header.SerializeToString()
signature = pybitcointools.ecdsa_sign(header_bytes, private_key)
batch = batch_pb2.Batch(header=header_bytes,
transactions=transactions,
signature=signature)
return batch
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 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_deserialized_wait_certificate(self):
wait_timer = \
EnclaveWaitTimer(
duration=3.14159,
previous_certificate_id='Smart, Maxwell Smart',
local_mean=2.71828)
wait_certificate = \
EnclaveWaitCertificate.wait_certificate_with_wait_timer(
wait_timer=wait_timer,
nonce='Eeny, meeny, miny, moe.',
block_digest='Indigestion. Pepto Bismol.')
serialized = wait_certificate.serialize()
signing_key = self._create_random_key()
wait_certificate.signature = \
pybitcointools.ecdsa_sign(serialized, signing_key)
copy_wait_certificate = \
EnclaveWaitCertificate.wait_certificate_from_serialized(
serialized,
wait_certificate.signature)
self.assertAlmostEquals(
wait_certificate.request_time,
copy_wait_certificate.request_time)
self.assertAlmostEquals(
wait_certificate.duration,
copy_wait_certificate.duration)
self.assertEqual(
wait_certificate.previous_certificate_id,
copy_wait_certificate.previous_certificate_id)
self.assertAlmostEquals(
wait_certificate.local_mean,
copy_wait_certificate.local_mean)
self.assertEqual(
wait_certificate.nonce,
copy_wait_certificate.nonce)
self.assertEqual(
wait_certificate.block_digest,
copy_wait_certificate.block_digest)
self.assertEqual(
wait_certificate.signature,
copy_wait_certificate.signature)
self.assertEqual(serialized, copy_wait_certificate.serialize())
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 create_jvm_sc_transaction(verb, private_key, public_key,
bytecode=None, methods=None, byte_addr=None,
method=None, parameters=None, addresses=None):
payload = JVM_SC_Payload(verb=verb, bytecode=bytecode,
methods=methods, byte_addr=byte_addr,
method=method, parameters=parameters)
if addresses is None:
addresses = []
# The prefix should eventually be looked up from the
# validator's namespace registry.
if byte_addr is not None:
addr = byte_addr
elif bytecode is not None:
addr = get_address('jvm_sc', bytecode)
else:
raise Exception
addresses.append(addr)
header = transaction_pb2.TransactionHeader(
signer=public_key,
family_name='jvm_sc',
family_version='1.0',
inputs=addresses,
outputs=addresses,
dependencies=[],
payload_encoding="application/protobuf",
payload_sha512=payload.sha512(),
batcher=public_key)
header_bytes = header.SerializeToString()
signature = pybitcointools.ecdsa_sign(
header_bytes,
private_key)
transaction = transaction_pb2.Transaction(
header=header_bytes,
payload=payload.payload_bytes,
signature=signature)
return transaction
def command(command, privkey):
command['cmd_num'] = fs_load()
increment_cmd_num()
cmd = package(command)
sig = package(pt.ecdsa_sign(cmd, privkey))
URL = urllib.urlopen(url.format(cmd, sig))
URL = URL.read()
print('url: ' + str(URL))
try:
out = unpackage(URL)
except:
print(URL)
print('out: ' + str())
return ''
if 'type' in out and out['type'] == 'cmd_num_error':
print('out: ' + str(out))
increment_cmd_num(1 + out['cmd_num'])
return command(command, privkey)
return out
def create_batch(transactions, private_key, public_key):
transaction_signatures = [t.signature for t in transactions]
header = batch_pb2.BatchHeader(
signer=public_key,
transaction_signatures=transaction_signatures)
header_bytes = header.SerializeToString()
signature = pybitcointools.ecdsa_sign(
header_bytes,
private_key)
batch = batch_pb2.Batch(
header=header_bytes,
transactions=transactions,
signature=signature)
return batch
def test_is_valid_pub_key(self):
pubkey = pybitcointools.privkey_to_pubkey("5KQ4iQQGgbQX9MmfiPUwwHBL1R"
"GPa86NwFbqrWoodjuzruqFVDd")
pub = pybitcointools.encode_pubkey(pubkey, "hex")
minfo = {'Nonce': 100, 'public_key': pub,
'TransactionType': '/Transaction', 'Dependencies': []}
sig = pybitcointools.ecdsa_sign(
signed_object.dict2cbor(minfo),
"5KQ4iQQGgbQX9MmfiPUwwHBL1RGPa86NwFbqrWoodjuzruqFVDd"
)
# Create valid transaction
minfo["Signature"] = sig
temp = Transaction(minfo)
self.assertTrue(temp.is_valid("unused"))
# Change transaction after it was signed
minfo["Nonce"] = time.time()
temp = Transaction(minfo)
self.assertFalse(temp.is_valid("unused"))
def command(command, privkey):
command['cmd_num']=fs_load()
increment_cmd_num()
cmd=package(command)
sig=package(pt.ecdsa_sign(cmd, privkey))
URL=urllib.urlopen(url.format(cmd, sig))
URL=URL.read()
print('url: ' +str(URL))
try:
out=unpackage(URL)
except:
print(URL)
print('out: ' +str())
return ''
if 'type' in out and out['type']=='cmd_num_error':
print('out: ' +str(out))
increment_cmd_num(1+out['cmd_num'])
return command(command, privkey)
return out
def test_is_valid_pub_key(self):
pubkey = pybitcointools.privkey_to_pubkey("5KQ4iQQGgbQX9MmfiPUwwHBL1R"
"GPa86NwFbqrWoodjuzruqFVDd")
pub = pybitcointools.encode_pubkey(pubkey, "hex")
minfo = {
'Nonce': 100,
'public_key': pub,
'TransactionType': '/Transaction',
'Dependencies': []
}
sig = pybitcointools.ecdsa_sign(
signed_object.dict2cbor(minfo),
"5KQ4iQQGgbQX9MmfiPUwwHBL1RGPa86NwFbqrWoodjuzruqFVDd")
# Create valid transaction
minfo["Signature"] = sig
temp = Transaction(minfo)
self.assertTrue(temp.is_valid("unused"))
# Change transaction after it was signed
minfo["Nonce"] = time.time()
temp = Transaction(minfo)
self.assertFalse(temp.is_valid("unused"))
def test_deserialized_wait_certificate(self):
wait_timer = \
EnclaveWaitTimer(
duration=3.14159,
previous_certificate_id='Smart, Maxwell Smart',
local_mean=2.71828)
wait_certificate = \
EnclaveWaitCertificate.wait_certificate_with_wait_timer(
wait_timer=wait_timer,
nonce='Eeny, meeny, miny, moe.',
block_digest='Indigestion. Pepto Bismol.')
serialized = wait_certificate.serialize()
signing_key = self._create_random_key()
wait_certificate.signature = \
pybitcointools.ecdsa_sign(serialized, signing_key)
copy_wait_certificate = \
EnclaveWaitCertificate.wait_certificate_from_serialized(
serialized,
wait_certificate.signature)
self.assertAlmostEquals(wait_certificate.request_time,
copy_wait_certificate.request_time)
self.assertAlmostEquals(wait_certificate.duration,
copy_wait_certificate.duration)
self.assertEqual(wait_certificate.previous_certificate_id,
copy_wait_certificate.previous_certificate_id)
self.assertAlmostEquals(wait_certificate.local_mean,
copy_wait_certificate.local_mean)
self.assertEqual(wait_certificate.nonce, copy_wait_certificate.nonce)
self.assertEqual(wait_certificate.block_digest,
copy_wait_certificate.block_digest)
self.assertEqual(wait_certificate.signature,
copy_wait_certificate.signature)
self.assertEqual(serialized, copy_wait_certificate.serialize())
def sign_data(self, data):
return pybitcointools.ecdsa_sign(data, self.private)
def sign_command(self, command):
return pybitcointools.ecdsa_sign(command, self._private)
def create_wait_certificate(cls, block_digest):
with cls._lock:
# If we don't have a PoET private key, then the enclave has not
# been properly initialized (either by calling create_signup_info
# or unseal_signup_data)
if cls._poet_private_key is None:
raise \
WaitCertificateError(
'Enclave must be initialized before attempting to '
'create a wait certificate')
# Several criteria we need to be met before we can create a wait
# certificate:
# 1. We have an active timer
# 2. The active timer has expired
# 3. The active timer has not timed out
if cls._active_wait_timer is None:
raise \
WaitCertificateError(
'Enclave active wait timer has not been initialized')
# HACK ALERT!! HACK ALERT!! HACK ALERT!! HACK ALERT!!
#
# Today, without the genesis utility we cannot make these checks.
# Once we have the genesis utility, this code needs to change to
# Depend upon the timer not being expired or timed out. The
# Original specification requires this check.
#
# HACK ALERT!! HACK ALERT!! HACK ALERT!! HACK ALERT!!
#
# if not cls._active_wait_timer.has_expired():
# raise \
# WaitCertificateError(
# 'Cannot create wait certificate because timer has '
# 'not expired')
# if wait_timer.has_timed_out():
# raise \
# WaitCertificateError(
# 'Cannot create wait certificate because timer '
# 'has timed out')
# Create a random nonce for the certificate. For our "random"
# nonce we will take the timer signature, concat that with the
# current time, JSON-ize it and create a SHA-256 hash over it.
# Probably not considered random by security professional
# standards, but it is good enough for the simulator.
random_string = \
dict2json({
'wait_timer_signature': cls._active_wait_timer.signature,
'now': datetime.datetime.utcnow().isoformat()
})
nonce = pybitcointools.sha256(random_string)
# First create a new enclave wait certificate using the data
# provided and then sign the certificate with the PoET private key
wait_certificate = \
EnclaveWaitCertificate.wait_certificate_with_wait_timer(
wait_timer=cls._active_wait_timer,
nonce=nonce,
block_digest=block_digest)
wait_certificate.signature = \
pybitcointools.ecdsa_sign(
wait_certificate.serialize(),
cls._poet_private_key)
# Now that we have created the certificate, we no longer have an
# active timer
cls._active_wait_timer = None
return wait_certificate
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 sign(message, privkey):
return pybitcointools.ecdsa_sign(message, privkey)
def sign_command(self, command):
return pybitcointools.ecdsa_sign(command, self._private)
