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 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 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 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 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_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 _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 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 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 setUp(self): self.private_key = Signing.create_private_key(base64.b64decode("7fDTiiCsCKG43Z8YlNelveKGwir6EpCHUhrcHDbFBgg="))