def __init__(self, recipient_key): if isinstance(recipient_key, PublicKey): self._public_key = recipient_key.encode( encoder=encoding.RawEncoder) self._private_key = None elif isinstance(recipient_key, PrivateKey): self._private_key = recipient_key.encode( encoder=encoding.RawEncoder) self._public_key = recipient_key.public_key.encode( encoder=encoding.RawEncoder) else: raise exc.TypeError( "SealedBox must be created from a PublicKey or a PrivateKey")
def __init__(self, private_key, public_key): if private_key and public_key: if not isinstance(private_key, PrivateKey) or not isinstance( public_key, PublicKey ): raise exc.TypeError( "Box must be created from " "a PrivateKey and a PublicKey" ) self._shared_key = nacl.bindings.crypto_box_beforenm( public_key.encode(encoder=encoding.RawEncoder), private_key.encode(encoder=encoding.RawEncoder), ) else: self._shared_key = None
def __init__(self, private_key, encoder=encoding.RawEncoder): # Decode the secret_key private_key = encoder.decode(private_key) # verify the given secret key type and size are correct if not (isinstance(private_key, bytes) and len(private_key) == self.SIZE): raise exc.TypeError( ("PrivateKey must be created from a {0} " "bytes long raw secret key").format(self.SIZE)) raw_public_key = nacl.bindings.crypto_scalarmult_base(private_key) self._private_key = private_key self.public_key = PublicKey(raw_public_key)
def __init__(self, private_key, encoder=encoding.RawEncoder): # Decode the secret_key private_key = encoder.decode(private_key) if not isinstance(private_key, bytes): raise exc.TypeError( "PrivateKey must be created from a 32 byte seed") # Verify that our seed is the proper size if len(private_key) != self.SIZE: raise exc.ValueError( "The secret key must be exactly %d bytes long" % self.SIZE) raw_public_key = nacl.bindings.crypto_scalarmult_base(private_key) self._private_key = private_key self.public_key = PublicKey(raw_public_key)
def randombytes_buf_deterministic(size, seed): """ Returns ``size`` number of deterministically generated pseudorandom bytes from a seed :param size: int :param seed: bytes :rtype: bytes """ if len(seed) != randombytes_SEEDBYTES: raise exc.TypeError("Deterministic random bytes must be generated " "from 32 bytes") buf = ffi.new("unsigned char[]", size) lib.randombytes_buf_deterministic(buf, size, seed) return ffi.buffer(buf, size)[:]
def __init__(self, seed, encoder=encoding.RawEncoder): # Decode the seed seed = encoder.decode(seed) if not isinstance(seed, bytes): raise exc.TypeError( "SigningKey must be created from a 32 byte seed") # Verify that our seed is the proper size if len(seed) != nacl.bindings.crypto_sign_SEEDBYTES: raise exc.ValueError("The seed must be exactly %d bytes long" % nacl.bindings.crypto_sign_SEEDBYTES) public_key, secret_key = nacl.bindings.crypto_sign_seed_keypair(seed) self._seed = seed self._signing_key = secret_key self.verify_key = VerifyKey(public_key)