def prueba(): if not os.path.exists("words.txt"): mnemo = Mnemonic("english") words = mnemo.generate(strength=256) with open("words.txt", 'w') as f: f.write(words) print(words) else: with open("words.txt", 'r') as f: words = f.read() print(words) w = Wallet(words) sk, pk = w.derive_account("TESTNET", account=0, address_index=0) sk = PrivateKey(sk) pk_bytes = bytes.fromhex(pk) if isinstance(pk, str) else pk if len(pk_bytes) != 64: pk_bytes = PublicKey(pk_bytes).format(False)[1:] print(sk.to_der())
def test_load_key_file(): dummy_sk = PrivateKey() dummy_sk_der = dummy_sk.to_der() # If file exists and has data in it, function should work. with open("key_test_file", "wb") as f: f.write(dummy_sk_der) Cryptographer.load_key_file("key_test_file") os.remove("key_test_file") # If file doesn't exist, function should return None with pytest.raises(InvalidParameter, match="file not found"): Cryptographer.load_key_file("nonexistent_file") with pytest.raises(InvalidParameter, match="file path was expected"): Cryptographer.load_key_file(0) with pytest.raises(InvalidParameter, match="file path was expected"): Cryptographer.load_key_file(None)
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()