def test_key_conversion(self): keypair_seed = (b"421151a459faeade3d247115f94aedae" b"42318124095afabe4d1451a559faedee") signing_key = SigningKey(binascii.unhexlify(keypair_seed)) verify_key = signing_key.verify_key private_key = bytes(signing_key.to_curve25519_private_key()) public_key = bytes(verify_key.to_curve25519_public_key()) assert tohex(private_key) == ("8052030376d47112be7f73ed7a019293" "dd12ad910b654455798b4667d73de166") assert tohex(public_key) == ("f1814f0e8ff1043d8a44d25babff3ced" "cae6c22c3edaa48f857ae70de2baae50")
class SOLAccount(BaseAccount): CHAIN = "SOL" CURVE = "curve25519" _signing_key: SigningKey _private_key: PrivateKey def __init__(self, private_key=None): self.private_key = private_key self._signing_key = SigningKey(self.private_key) self._private_key = self._signing_key.to_curve25519_private_key() async def sign_message(self, message: Dict) -> Dict: """Sign a message inplace.""" message = self._setup_sender(message) verif = get_verification_buffer(message) sig = { "publicKey": self.get_address(), "signature": encode(self._signing_key.sign(verif).signature), } message["signature"] = json.dumps(sig) return message def get_address(self) -> str: return encode(self._signing_key.verify_key) def get_public_key(self) -> str: return bytes( self._signing_key.verify_key.to_curve25519_public_key()).hex() async def encrypt(self, content) -> bytes: value: bytes = bytes( SealedBox(self._private_key.public_key).encrypt(content)) return value async def decrypt(self, content) -> bytes: value: bytes = SealedBox(self._private_key).decrypt(content) return value
class NACL: KEY_SIZE = 32 def __init__(self, private_key=None, symmetric_key=None): """Constructor for nacl object Args: private_key (bytes, optional): The private key used to sign and encrypt the data. Generated randomly if not given. symmetric_key (bytes, optional): The key used for symmetric encryption. Generated randomly if not given. """ self.signing_key = SigningKey( private_key) if private_key else SigningKey.generate() self.verify_key = self.signing_key.verify_key self.private_key = self.signing_key.to_curve25519_private_key() self.public_key = self.private_key.public_key self.symmetric_key = nacl.utils.random( NACL.KEY_SIZE) if symmetric_key is None else symmetric_key self.symmetric_box = SecretBox(self.symmetric_key) def encrypt(self, message, reciever_public_key): """Encrypt the message to send to a receiver. (public key encryption) Args: message (bytes): The message to be encrypted. reciever_public_key (bytes): The receiver's public key. Returns: bytes: The encrypted message """ return Box(self.private_key, PublicKey(reciever_public_key)).encrypt(message) def decrypt(self, message, sender_public_key): """Decrypt a received message. (public key encryption) Args: message (bytes): The encrypted message. sender_public_key (bytes): The public key of the sender. Returns: bytes: The decrypted message """ return Box(self.private_key, PublicKey(sender_public_key)).decrypt(message) def encrypt_symmetric(self, message): """Encrypt the message to send to a receiver. (secret key encryption) Args: message (bytes): The message to be encrypted. Returns: bytes: The encrypted message """ return self.symmetric_box.encrypt(message) def decrypt_symmetric(self, message, symmetric_key): """Decrypt the receiver message. (secret key encryption) Args: message (bytes): The message to be decrypted. Returns: bytes: The decrypted message """ return SecretBox(symmetric_key).decrypt(message) def sign(self, message): """Sign the message and return the messsage and the signature. Args: message (bytes): The message to be signed Returns: bytes, bytes: The message and the signature. """ signed = self.signing_key.sign(message) return message, signed.signature def sign_hex(self, message): """Sign the message and return the messsage and the signature. Args: message (bytes): The message to be signed Returns: bytes: The message and the signature. """ signed = self.signing_key.sign(message) signedhex = binascii.hexlify(signed.signature) return signedhex def verify(self, message, signature, verification_key): """Verify that the signature using the verification key Args: message (bytes): The received message. signature (bytes): The recieved signature. verification_key (bytes): The verification key. Returns: bool: True if the verification succeeds. """ try: VerifyKey(verification_key).verify(message, signature) return True except BadSignatureError: return False def get_signing_seed(self): """Returns the signing seed (same as the private key). Returns: bytes: The 32-bit signing key. """ return bytes(self.signing_key._seed) def get_verification_key(self): """Returns the verification key. Returns: bytes: The verification key. """ return bytes(self.verify_key) def get_verify_key_hex(self): return binascii.hexlify(self.verify_key.encode()).decode() def get_public_key_hex(self): return binascii.hexlify(self.public_key.encode()).decode() def get_public_key(self): """Getter for the public key. Returns: bytes: The public key. """ return bytes(self.public_key) def get_private_key(self): """Getter for the private key. Returns: bytes: The private key. """ return bytes(self.private_key) def get_symmetric_key(self): """Getter for the symmetric key. Returns: bytes: The symmetric key. """ return bytes(self.symmetric_key)