def test_hdkf(self): derived = HKDF(b'secret', 32, b'', SHA256).hex() self.assertEqual( derived, "2f34e5ff91ec85d53ca9b543683174d0cf550b60d5f52b24c97b386cfcf6cbbf") k1 = PrivateKey(secret=bytes([2])) self.assertEqual(k1.to_int(), 2) k2 = PrivateKey(secret=bytes([3])) self.assertEqual(k2.to_int(), 3) self.assertEqual(encapsulate(k1, k2.public_key), decapsulate(k1.public_key, k2)) self.assertEqual( encapsulate(k1, k2.public_key).hex(), "6f982d63e8590c9d9b5b4c1959ff80315d772edd8f60287c9361d548d5200f82")
class BaseKey: """This class represents a point on the elliptic curve secp256k1 and provides all necessary cryptographic functionality. You shouldn't use this class directly. :param wif: A private key serialized to the Wallet Import Format. If the argument is not supplied, a new private key will be created. The WIF compression flag will be adhered to, but the version byte is disregarded. Compression will be used by all new keys. :type wif: ``str`` :raises TypeError: If ``wif`` is not a ``str``. """ def __init__(self, wif=None): if wif: if isinstance(wif, str): private_key_bytes, compressed, version = wif_to_bytes(wif) self._pk = ECPrivateKey(private_key_bytes) elif isinstance(wif, ECPrivateKey): self._pk = wif compressed = True else: raise TypeError('Wallet Import Format must be a string.') else: self._pk = ECPrivateKey() compressed = True self._public_point = None self._public_key = self._pk.public_key.format(compressed=compressed) @property def public_key(self): """The public point serialized to bytes.""" return self._public_key @property def public_point(self): """The public point (x, y).""" if self._public_point is None: self._public_point = Point(*public_key_to_coords(self._public_key)) return self._public_point def sign(self, data): """Signs some data which can be verified later by others using the public key. :param data: The message to sign. :type data: ``bytes`` :returns: A signature compliant with BIP-62. :rtype: ``bytes`` """ return self._pk.sign(data) def verify(self, signature, data): """Verifies some data was signed by this private key. :param signature: The signature to verify. :type signature: ``bytes`` :param data: The data that was supposedly signed. :type data: ``bytes`` :rtype: ``bool`` """ return self._pk.public_key.verify(signature, data) def pub_to_hex(self): """:rtype: ``str`` """ return bytes_to_hex(self.public_key) def to_hex(self): """:rtype: ``str``""" return self._pk.to_hex() def to_bytes(self): """:rtype: ``bytes``""" return self._pk.secret def to_der(self): """:rtype: ``bytes``""" return self._pk.to_der() def to_pem(self): """:rtype: ``bytes``""" return self._pk.to_pem() def to_int(self): """:rtype: ``int``""" return self._pk.to_int() def is_compressed(self): """Returns whether or not this private key corresponds to a compressed public key. :rtype: ``bool`` """ return True if len(self.public_key) == 33 else False def __eq__(self, other): return self.to_int() == other.to_int()