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)