def setUp(self):
self.private_key_0 = Signing.create_private_key(
base64.b64decode("7fDTiiCsCKG43Z8YlNelveKGwir6EpCHUhrcHDbFBgg="))
self.private_key_1 = Signing.create_private_key(
base64.b64decode("Lw1VCeY6gn8k8IRlD+TeadxN0BXGibBQWN9hst+qvFs="))
self.public_key_bin_0 = self.private_key_0.get_verifying_key(
).to_string()
self.public_key_bin_1 = self.private_key_1.get_verifying_key(
).to_string()
def get_private_keys(b64_encoded_priv_keys):
keys = []
for pk in b64_encoded_priv_keys:
dec_priv_key = decode(pk)
keys.append(Signing.create_private_key(dec_priv_key))
assert len(keys) == len(set(keys)), "Private keys in provided list are not unique (some of them are provided multiple times)."
return keys
def main():
args = parse_args()
if args.subcommand == 'create-transfer-tx':
if args.private_key:
priv_keys = get_private_keys(args.private_key)
else:
priv_keys = [Signing.generate_private_key()]
if args.public_key_to:
pub_key_to_bin = decode(args.public_key_to)
else:
pub_key_to_bin = Signing.generate_private_key().get_verifying_key().to_string()
tx = create_signed_transfer_transaction(priv_keys, pub_key_to_bin, amount=args.amount, fee=args.fee)
print(tx.to_wire_format(include_metadata=args.include_metadata))
elif args.subcommand == 'create-wealth-tx':
if args.private_key:
priv_keys = get_private_keys(args.private_key)
else:
priv_keys = [Signing.generate_private_key()]
tx = create_signed_wealth_transaction(priv_keys, amount=args.amount, fee=args.fee)
print(tx.to_wire_format(include_metadata=args.include_metadata))
elif args.subcommand == 'verify-tx':
if args.filename:
with open(args.filename, 'r') as f:
wire_tx = f.read()
else:
wire_tx = args.tx_wire_format_string
tx = Tx.from_wire_format(wire_tx)
if args.print_metadata:
print(tx)
#print("hex:\n{}".format(tx))
#print("bin64:\n{}".format(tx.getMetadataDict()))
if tx.verify():
msg = "SUCCESSFULLY verified."
else:
msg = "FAILED to verify."
print(msg)
def update(self):
if not self._is_invalidated:
return
self._signing_io_stream.seek(0)
TxBase.serialise(self, self._signing_io_stream)
self._base_data_size = self._signing_io_stream.tell()
self._base_hasher = Signing.digest()
self._base_hasher.update(TxBase.serialised_tx_base_data(self))
def test_sign_verify_cycle_for_random_generated_transactions(self):
private_keys = []
for _ in range(0, random.randint(1, 5)):
private_keys.append(Signing.generate_private_key())
for _ in range(0, 5):
tx = self.generate_random_tx(private_keys=private_keys,
resources_count=random.randint(1, 5))
assert tx.verify(), "Tx: {}".format(tx)
def _print_sign_data(self, prefix, digest, identity_serialised_data):
print(
'{}: digest[hex]={},\ntx_ser_data[hex]={}.\nidentity_ser_data[hex]={}\n'
.format(prefix, binascii.hexlify(digest),
binascii.hexlify(self._signing_io_stream.getvalue()),
binascii.hexlify(identity_serialised_data)))
stream = io.BytesIO()
stream.write(self._signing_io_stream.getvalue())
stream.write(identity_serialised_data)
hash = Signing.digest()
hash.update(stream.getvalue())
print('{}: digest[hex]={},\nhashed_data[hex]={}'.format(
prefix, binascii.hexlify(hash.digest()),
binascii.hexlify(stream.getvalue())))
def sign(self, private_key):
if isinstance(private_key, ecdsa.SigningKey):
priv_key = private_key
elif isinstance(private_key, bytes):
priv_key = Signing.create_private_key(private_key)
else:
raise TypeError(
"Input private key is neither `ecdsa.SigningKey` type nor `bytes` type."
)
digest, identity = self.digest_for_signing(
priv_key.get_verifying_key().to_string())
signature_data = priv_key.sign_digest(digest)
signature = Signature(data=signature_data)
return identity, signature
def test_sign_to_from_wire_verify_cycle_for_random_generated_transactions(
self):
private_keys = []
for _ in range(0, random.randint(1, 5)):
private_keys.append(Signing.generate_private_key())
for _ in range(0, 5):
tx = self.generate_random_tx(private_keys=private_keys,
resources_count=random.randint(1, 5))
tx_wire = tx.to_wire_format(include_metadata=True)
tx_des = Tx.from_wire_format(tx_wire)
assert tx.verify(), "Tx: {}\n{}".format(tx, tx_wire)
assert tx_des.verify(), "Tx: {}".format(tx_des)
assert tx_des == tx, "Tx:\n{}\nTx des:\n{}".format(tx, tx_des)
def verify(self, signature_data, public_key):
if isinstance(public_key, ecdsa.VerifyingKey):
pub_key = public_key
elif isinstance(public_key, bytes):
pub_key = Signing.create_public_key(public_key)
else:
raise TypeError(
"Input public key is neither `ecdsa.VerifyingKey` type nor `bytes` type."
)
digest, _ = self.digest_for_signing(pub_key.to_string())
try:
pub_key.verify_digest(signature_data, digest)
return True
except ecdsa.keys.BadSignatureError:
pass
return False
def generate_random_tx(cls, private_keys=None, resources_count=1):
tx = Tx()
tx.contract_name = cls.generate_random_string(10).encode()
tx.fee = random.randint(0, 10000)
resources = set()
for _ in range(0, resources_count):
resources.add(cls.generate_random_string(10).encode())
tx.resources = resources
tx.data = cls.generate_random_string(10).encode()
if private_keys is None:
private_keys = [Signing.generate_private_key().to_string()]
for pk in private_keys:
tx.sign(pk)
return tx
def setUp(self):
self.private_key = Signing.create_private_key(
base64.b64decode("7fDTiiCsCKG43Z8YlNelveKGwir6EpCHUhrcHDbFBgg="))