def test_dumps(self): ref = Entity() stream = StringIO() ref.dump(stream, SUPER_SECURE_PASSWORD) stream.seek(0) other = Entity.load(stream, SUPER_SECURE_PASSWORD) self.assertEqual(ref.private_key, other.private_key)
def test_hashing_not_equal(self): entity1 = Entity() entity2 = Entity() addr1 = Address(entity1) addr2 = Address(entity2) self.assertNotEqual(hash(addr1), hash(addr2))
def test_prompt_dump(self): ref = Entity() stream = StringIO() with patch('getpass.getpass') as mock_getpass: mock_getpass.side_effect = [ WEAK_PASSWORD, SUPER_SECURE_PASSWORD, WEAK_PASSWORD, SUPER_SECURE_PASSWORD ] ref.prompt_dump(stream) stream.seek(0)
def test_construction_from_bytes(self): # create a reference and a copy of the entity reference = Entity() other = Entity(reference.private_key_bytes) self.assertEqual(reference.private_key_bytes, other.private_key_bytes) self.assertEqual(reference.private_key, other.private_key) self.assertEqual(reference.private_key_hex, other.private_key_hex) self.assertEqual(reference.public_key_bytes, other.public_key_bytes) self.assertEqual(reference.public_key, other.public_key) self.assertEqual(reference.public_key_hex, other.public_key_hex)
def test_prompt_load(self): ref = Entity() stream = StringIO() # write the entity to the stream ref.dump(stream, SUPER_SECURE_PASSWORD) # reset the stream stream.seek(0) with patch('getpass.getpass') as mock_getpass: mock_getpass.side_effect = [SUPER_SECURE_PASSWORD] other = Entity.prompt_load(stream) self.assertEqual(other.private_key, ref.private_key)
def test_generation(self): entity = Entity() self.assertEqual(32, len(entity.private_key_bytes)) # check the other binary representations self.assertEqual( base64.b64encode(entity.private_key_bytes).decode(), entity.private_key) self.assertEqual(entity.private_key_bytes.hex(), entity.private_key_hex) signing_key = ecdsa.SigningKey.from_string( entity.private_key_bytes, curve=Entity.curve, hashfunc=Entity.hash_function) verifying_key = signing_key.get_verifying_key() self.assertEqual(verifying_key.to_string(), entity.public_key_bytes) # check the other binary representations self.assertEqual( base64.b64encode(entity.public_key_bytes).decode(), entity.public_key) self.assertEqual(entity.public_key_bytes.hex(), entity.public_key_hex)
def test_hex_display(self): entity = Entity() address = Address(entity) address_bytes = bytes(address) hex_address = address_bytes.hex() self.assertEqual(hex_address, address.to_hex())
def test_hex_display(self): entity = Entity() address = Address(entity) address_bytes = bytes(address) hex_address = binascii.hexlify(address_bytes).decode() self.assertEqual(hex_address, address.to_hex())
def test_construction_from_strings(self): ref = Entity() test1 = Identity.from_hex(ref.public_key_hex) self.assertEqual(ref, test1) test2 = Identity.from_base64(ref.public_key) self.assertEqual(ref, test2)
def test_construction_from_verifying_key(self): entity = Entity() # create a private / public key pair # create the identity from the identity (copy) identity = Identity(entity.verifying_key) # ensure the they are the same self.assertEqual(identity.public_key_bytes, entity.public_key_bytes)
def test_invalid_display(self): entity = Entity() address = Address(entity) address_bytes = bytes(address) invalid_checksum = bytes([0] * Address.CHECKSUM_SIZE) invalid_display = base58.b58encode(address_bytes + invalid_checksum).decode() with self.assertRaises(ValueError): _ = Address(invalid_display)
def test_construction_from_identity(self): entity = Entity() address = Address(entity) # manually compute the address value expected_address_bytes, expected_display = _calc_address(entity.public_key_bytes) self.assertEqual(expected_address_bytes, bytes(address)) self.assertEqual(expected_display, str(address))
def test_construction_from_string(self): entity = Entity() # manually compute the address value expected_address_bytes, expected_display = _calc_address(entity.public_key_bytes) # re-create the address from the display string address = Address(expected_display) self.assertEqual(bytes(address), expected_address_bytes) self.assertEqual(str(address), expected_display)
def test_supports_collections(self): entity = Entity() # create a series of identities identity1 = Identity(entity) identity2 = Identity(entity) identity3 = Identity(identity2) identity_list = [identity1, identity2, identity3] self.assertEqual(len(identity_list), 3) self.assertIn(identity1, identity_list) self.assertIn(identity2, identity_list) self.assertIn(identity3, identity_list) # due to the fact that each identity is the name, the first element will always be matched self.assertEqual(identity_list.index(identity1), 0) self.assertEqual(identity_list.index(identity2), 0) self.assertEqual(identity_list.index(identity3), 0) identity_set = set(identity_list) self.assertEqual(len(identity_set), 1) self.assertIn(identity1, identity_set) self.assertIn(identity2, identity_set) self.assertIn(identity3, identity_set)
def test_signing_verifying_cycle(self): entity = Entity() payload = 'foo bar is a baz' # sign the payload signature = entity.sign(payload.encode()) # verify the payload self.assertTrue(entity.verify(payload.encode(), signature)) # modify the signature slightly bad_signature = bytes([(signature[0] + 1) & 0xff]) + signature[1:] self.assertFalse(entity.verify(payload.encode(), bad_signature)) # also ensure a different payload is not verifiable self.assertFalse( entity.verify('foo bar is not a baz'.encode(), signature))
def test_construction_from_address(self): entity = Entity() address1 = Address(entity) address2 = Address(address1) self.assertEqual(bytes(address1), bytes(address2))
def test_equality(self): entity = Entity() addr1 = Address(entity) addr2 = Address(entity) self.assertEqual(addr1, addr2)
def test_not_equal(self): entity1 = Entity() entity2 = Entity() self.assertNotEqual(entity1, entity2)
def test_construction_from_identity(self): entity = Entity() # create a private / public key pair identity = Identity(entity) self.assertEqual(entity.public_key_bytes, identity.public_key_bytes)
from fetchai.ledger.crypto.address import Address from fetchai.ledger.crypto.entity import Entity from fetchai.ledger.crypto.identity import Identity from fetchai.ledger.serialisation import transaction, bytearray from fetchai.ledger.serialisation.sha256 import sha256_hex from fetchai.ledger.transaction import Transaction _PRIVATE_KEYS = ( '1411d53f88e736eac7872430dbe5b55ac28c17a3e648c388e0bd1b161ab04427', '3436c184890d498b25bc2b5cb0afb6bad67379ebd778eae1de40b6e0f0763825', '4a56a19355f934174f6388b3c80598abb151af79c23d5a7af45a13357fb71253', 'f9d67ec139eb7a1cb1f627357995847392035c1e633e8530de5ab5d04c6e9c33', '80f0e1c69e5f1216f32647c20d744c358e0894ebc855998159017a5acda208ba', ) ENTITIES = [Entity.from_hex(x) for x in _PRIVATE_KEYS] IDENTITIES = [Identity(x) for x in ENTITIES] def _calculate_integer_stream_size(length: int) -> int: if length < 0x80: return 1 elif length < 0x100: return 2 elif length < 0x1000: return 4 else: return 8 class TransactionSerialisation(unittest.TestCase):
def test_hashing_equal(self): entity = Entity() addr1 = Address(entity) addr2 = Address(entity) self.assertEqual(hash(addr1), hash(addr2))
def test_signing_key(self): entity = Entity() self.assertIsInstance(entity.signing_key, ecdsa.SigningKey)
def test_invalid_construction(self): with self.assertRaises(RuntimeError): _ = Entity(str())
def test_construction_from_base64(self): ref = Entity() ref_key = ref.private_key other = Entity.from_base64(ref_key) self.assertEqual(ref.private_key_bytes, other.private_key_bytes)
def test_dump_failure_on_weak_password(self): stream = StringIO() with self.assertRaises(RuntimeError): Entity().dump(stream, WEAK_PASSWORD)
def test_dumps_failure_on_weak_password(self): with self.assertRaises(RuntimeError): Entity().dumps(WEAK_PASSWORD)
def test_loads(self): ref = Entity() value = ref.dumps(SUPER_SECURE_PASSWORD) other = Entity.loads(value, SUPER_SECURE_PASSWORD) self.assertEqual(ref.private_key, other.private_key)
def test_conversion_from_hex(self): ref = Entity() other = Entity.from_hex(ref.private_key_hex) self.assertEqual(ref.private_key, other.private_key)