File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/nacl.zip
Back
PK �#�Z�Bu�0 0 hashlib.pynu �[��� # Copyright 2016-2019 Donald Stufft and individual contributors # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import binascii from typing import NoReturn import nacl.bindings from nacl.utils import bytes_as_string BYTES = nacl.bindings.crypto_generichash_BYTES BYTES_MIN = nacl.bindings.crypto_generichash_BYTES_MIN BYTES_MAX = nacl.bindings.crypto_generichash_BYTES_MAX KEYBYTES = nacl.bindings.crypto_generichash_KEYBYTES KEYBYTES_MIN = nacl.bindings.crypto_generichash_KEYBYTES_MIN KEYBYTES_MAX = nacl.bindings.crypto_generichash_KEYBYTES_MAX SALTBYTES = nacl.bindings.crypto_generichash_SALTBYTES PERSONALBYTES = nacl.bindings.crypto_generichash_PERSONALBYTES SCRYPT_AVAILABLE = nacl.bindings.has_crypto_pwhash_scryptsalsa208sha256 _b2b_init = nacl.bindings.crypto_generichash_blake2b_init _b2b_final = nacl.bindings.crypto_generichash_blake2b_final _b2b_update = nacl.bindings.crypto_generichash_blake2b_update class blake2b: """ :py:mod:`hashlib` API compatible blake2b algorithm implementation """ MAX_DIGEST_SIZE = BYTES MAX_KEY_SIZE = KEYBYTES_MAX PERSON_SIZE = PERSONALBYTES SALT_SIZE = SALTBYTES def __init__( self, data: bytes = b"", digest_size: int = BYTES, key: bytes = b"", salt: bytes = b"", person: bytes = b"", ): """ :py:class:`.blake2b` algorithm initializer :param data: :type data: bytes :param int digest_size: the requested digest size; must be at most :py:attr:`.MAX_DIGEST_SIZE`; the default digest size is :py:data:`.BYTES` :param key: the key to be set for keyed MAC/PRF usage; if set, the key must be at most :py:data:`.KEYBYTES_MAX` long :type key: bytes :param salt: a initialization salt at most :py:attr:`.SALT_SIZE` long; it will be zero-padded if needed :type salt: bytes :param person: a personalization string at most :py:attr:`.PERSONAL_SIZE` long; it will be zero-padded if needed :type person: bytes """ self._state = _b2b_init( key=key, salt=salt, person=person, digest_size=digest_size ) self._digest_size = digest_size if data: self.update(data) @property def digest_size(self) -> int: return self._digest_size @property def block_size(self) -> int: return 128 @property def name(self) -> str: return "blake2b" def update(self, data: bytes) -> None: _b2b_update(self._state, data) def digest(self) -> bytes: _st = self._state.copy() return _b2b_final(_st) def hexdigest(self) -> str: return bytes_as_string(binascii.hexlify(self.digest())) def copy(self) -> "blake2b": _cp = type(self)(digest_size=self.digest_size) _st = self._state.copy() _cp._state = _st return _cp def __reduce__(self) -> NoReturn: """ Raise the same exception as hashlib's blake implementation on copy.copy() """ raise TypeError( "can't pickle {} objects".format(self.__class__.__name__) ) def scrypt( password: bytes, salt: bytes = b"", n: int = 2 ** 20, r: int = 8, p: int = 1, maxmem: int = 2 ** 25, dklen: int = 64, ) -> bytes: """ Derive a cryptographic key using the scrypt KDF. :raises nacl.exceptions.UnavailableError: If called when using a minimal build of libsodium. Implements the same signature as the ``hashlib.scrypt`` implemented in cpython version 3.6 """ return nacl.bindings.crypto_pwhash_scryptsalsa208sha256_ll( password, salt, n, r, p, maxmem=maxmem, dklen=dklen ) PK �#�Z��*hL/ L/ secret.pynu �[��� # Copyright 2013 Donald Stufft and individual contributors # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import ClassVar, Optional import nacl.bindings from nacl import encoding from nacl import exceptions as exc from nacl.utils import EncryptedMessage, StringFixer, random class SecretBox(encoding.Encodable, StringFixer): """ The SecretBox class encrypts and decrypts messages using the given secret key. The ciphertexts generated by :class:`~nacl.secret.Secretbox` include a 16 byte authenticator which is checked as part of the decryption. An invalid authenticator will cause the decrypt function to raise an exception. The authenticator is not a signature. Once you've decrypted the message you've demonstrated the ability to create arbitrary valid message, so messages you send are repudiable. For non-repudiable messages, sign them after encryption. Encryption is done using `XSalsa20-Poly1305`_, and there are no practical limits on the number or size of messages (up to 2⁶⁴ messages, each up to 2⁶⁴ bytes). .. _XSalsa20-Poly1305: https://doc.libsodium.org/secret-key_cryptography/secretbox#algorithm-details :param key: The secret key used to encrypt and decrypt messages :param encoder: The encoder class used to decode the given key :cvar KEY_SIZE: The size that the key is required to be. :cvar NONCE_SIZE: The size that the nonce is required to be. :cvar MACBYTES: The size of the authentication MAC tag in bytes. :cvar MESSAGEBYTES_MAX: The maximum size of a message which can be safely encrypted with a single key/nonce pair. """ KEY_SIZE: ClassVar[int] = nacl.bindings.crypto_secretbox_KEYBYTES NONCE_SIZE: ClassVar[int] = nacl.bindings.crypto_secretbox_NONCEBYTES MACBYTES: ClassVar[int] = nacl.bindings.crypto_secretbox_MACBYTES MESSAGEBYTES_MAX: ClassVar[ int ] = nacl.bindings.crypto_secretbox_MESSAGEBYTES_MAX def __init__( self, key: bytes, encoder: encoding.Encoder = encoding.RawEncoder ): key = encoder.decode(key) if not isinstance(key, bytes): raise exc.TypeError("SecretBox must be created from 32 bytes") if len(key) != self.KEY_SIZE: raise exc.ValueError( "The key must be exactly %s bytes long" % self.KEY_SIZE, ) self._key = key def __bytes__(self) -> bytes: return self._key def encrypt( self, plaintext: bytes, nonce: Optional[bytes] = None, encoder: encoding.Encoder = encoding.RawEncoder, ) -> EncryptedMessage: """ Encrypts the plaintext message using the given `nonce` (or generates one randomly if omitted) and returns the ciphertext encoded with the encoder. .. warning:: It is **VITALLY** important that the nonce is a nonce, i.e. it is a number used only once for any given key. If you fail to do this, you compromise the privacy of the messages encrypted. Give your nonces a different prefix, or have one side use an odd counter and one an even counter. Just make sure they are different. :param plaintext: [:class:`bytes`] The plaintext message to encrypt :param nonce: [:class:`bytes`] The nonce to use in the encryption :param encoder: The encoder to use to encode the ciphertext :rtype: [:class:`nacl.utils.EncryptedMessage`] """ if nonce is None: nonce = random(self.NONCE_SIZE) if len(nonce) != self.NONCE_SIZE: raise exc.ValueError( "The nonce must be exactly %s bytes long" % self.NONCE_SIZE, ) ciphertext = nacl.bindings.crypto_secretbox( plaintext, nonce, self._key ) encoded_nonce = encoder.encode(nonce) encoded_ciphertext = encoder.encode(ciphertext) return EncryptedMessage._from_parts( encoded_nonce, encoded_ciphertext, encoder.encode(nonce + ciphertext), ) def decrypt( self, ciphertext: bytes, nonce: Optional[bytes] = None, encoder: encoding.Encoder = encoding.RawEncoder, ) -> bytes: """ Decrypts the ciphertext using the `nonce` (explicitly, when passed as a parameter or implicitly, when omitted, as part of the ciphertext) and returns the plaintext message. :param ciphertext: [:class:`bytes`] The encrypted message to decrypt :param nonce: [:class:`bytes`] The nonce used when encrypting the ciphertext :param encoder: The encoder used to decode the ciphertext. :rtype: [:class:`bytes`] """ # Decode our ciphertext ciphertext = encoder.decode(ciphertext) if nonce is None: # If we were given the nonce and ciphertext combined, split them. nonce = ciphertext[: self.NONCE_SIZE] ciphertext = ciphertext[self.NONCE_SIZE :] if len(nonce) != self.NONCE_SIZE: raise exc.ValueError( "The nonce must be exactly %s bytes long" % self.NONCE_SIZE, ) plaintext = nacl.bindings.crypto_secretbox_open( ciphertext, nonce, self._key ) return plaintext class Aead(encoding.Encodable, StringFixer): """ The AEAD class encrypts and decrypts messages using the given secret key. Unlike :class:`~nacl.secret.SecretBox`, AEAD supports authenticating non-confidential data received alongside the message, such as a length or type tag. Like :class:`~nacl.secret.Secretbox`, this class provides authenticated encryption. An inauthentic message will cause the decrypt function to raise an exception. Likewise, the authenticator should not be mistaken for a (public-key) signature: recipients (with the ability to decrypt messages) are capable of creating arbitrary valid message; in particular, this means AEAD messages are repudiable. For non-repudiable messages, sign them after encryption. The cryptosystem used is `XChacha20-Poly1305`_ as specified for `standardization`_. There are `no practical limits`_ to how much can safely be encrypted under a given key (up to 2⁶⁴ messages each containing up to 2⁶⁴ bytes). .. _standardization: https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-xchacha .. _XChacha20-Poly1305: https://doc.libsodium.org/secret-key_cryptography/aead#xchacha-20-poly1305 .. _no practical limits: https://doc.libsodium.org/secret-key_cryptography/aead#limitations :param key: The secret key used to encrypt and decrypt messages :param encoder: The encoder class used to decode the given key :cvar KEY_SIZE: The size that the key is required to be. :cvar NONCE_SIZE: The size that the nonce is required to be. :cvar MACBYTES: The size of the authentication MAC tag in bytes. :cvar MESSAGEBYTES_MAX: The maximum size of a message which can be safely encrypted with a single key/nonce pair. """ KEY_SIZE = nacl.bindings.crypto_aead_xchacha20poly1305_ietf_KEYBYTES NONCE_SIZE = nacl.bindings.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES MACBYTES = nacl.bindings.crypto_aead_xchacha20poly1305_ietf_ABYTES MESSAGEBYTES_MAX = ( nacl.bindings.crypto_aead_xchacha20poly1305_ietf_MESSAGEBYTES_MAX ) def __init__( self, key: bytes, encoder: encoding.Encoder = encoding.RawEncoder, ): key = encoder.decode(key) if not isinstance(key, bytes): raise exc.TypeError("AEAD must be created from 32 bytes") if len(key) != self.KEY_SIZE: raise exc.ValueError( "The key must be exactly %s bytes long" % self.KEY_SIZE, ) self._key = key def __bytes__(self) -> bytes: return self._key def encrypt( self, plaintext: bytes, aad: bytes = b"", nonce: Optional[bytes] = None, encoder: encoding.Encoder = encoding.RawEncoder, ) -> EncryptedMessage: """ Encrypts the plaintext message using the given `nonce` (or generates one randomly if omitted) and returns the ciphertext encoded with the encoder. .. warning:: It is vitally important for :param nonce: to be unique. By default, it is generated randomly; [:class:`Aead`] uses XChacha20 for extended (192b) nonce size, so the risk of reusing random nonces is negligible. It is *strongly recommended* to keep this behaviour, as nonce reuse will compromise the privacy of encrypted messages. Should implicit nonces be inadequate for your application, the second best option is using split counters; e.g. if sending messages encrypted under a shared key between 2 users, each user can use the number of messages it sent so far, prefixed or suffixed with a 1bit user id. Note that the counter must **never** be rolled back (due to overflow, on-disk state being rolled back to an earlier backup, ...) :param plaintext: [:class:`bytes`] The plaintext message to encrypt :param nonce: [:class:`bytes`] The nonce to use in the encryption :param encoder: The encoder to use to encode the ciphertext :rtype: [:class:`nacl.utils.EncryptedMessage`] """ if nonce is None: nonce = random(self.NONCE_SIZE) if len(nonce) != self.NONCE_SIZE: raise exc.ValueError( "The nonce must be exactly %s bytes long" % self.NONCE_SIZE, ) ciphertext = nacl.bindings.crypto_aead_xchacha20poly1305_ietf_encrypt( plaintext, aad, nonce, self._key ) encoded_nonce = encoder.encode(nonce) encoded_ciphertext = encoder.encode(ciphertext) return EncryptedMessage._from_parts( encoded_nonce, encoded_ciphertext, encoder.encode(nonce + ciphertext), ) def decrypt( self, ciphertext: bytes, aad: bytes = b"", nonce: Optional[bytes] = None, encoder: encoding.Encoder = encoding.RawEncoder, ) -> bytes: """ Decrypts the ciphertext using the `nonce` (explicitly, when passed as a parameter or implicitly, when omitted, as part of the ciphertext) and returns the plaintext message. :param ciphertext: [:class:`bytes`] The encrypted message to decrypt :param nonce: [:class:`bytes`] The nonce used when encrypting the ciphertext :param encoder: The encoder used to decode the ciphertext. :rtype: [:class:`bytes`] """ # Decode our ciphertext ciphertext = encoder.decode(ciphertext) if nonce is None: # If we were given the nonce and ciphertext combined, split them. nonce = ciphertext[: self.NONCE_SIZE] ciphertext = ciphertext[self.NONCE_SIZE :] if len(nonce) != self.NONCE_SIZE: raise exc.ValueError( "The nonce must be exactly %s bytes long" % self.NONCE_SIZE, ) plaintext = nacl.bindings.crypto_aead_xchacha20poly1305_ietf_decrypt( ciphertext, aad, nonce, self._key ) return plaintext PK �#�Z��S�9 �9 public.pynu �[��� # Copyright 2013 Donald Stufft and individual contributors # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import ClassVar, Generic, Optional, Type, TypeVar import nacl.bindings from nacl import encoding from nacl import exceptions as exc from nacl.encoding import Encoder from nacl.utils import EncryptedMessage, StringFixer, random class PublicKey(encoding.Encodable, StringFixer): """ The public key counterpart to an Curve25519 :class:`nacl.public.PrivateKey` for encrypting messages. :param public_key: [:class:`bytes`] Encoded Curve25519 public key :param encoder: A class that is able to decode the `public_key` :cvar SIZE: The size that the public key is required to be """ SIZE: ClassVar[int] = nacl.bindings.crypto_box_PUBLICKEYBYTES def __init__( self, public_key: bytes, encoder: encoding.Encoder = encoding.RawEncoder, ): self._public_key = encoder.decode(public_key) if not isinstance(self._public_key, bytes): raise exc.TypeError("PublicKey must be created from 32 bytes") if len(self._public_key) != self.SIZE: raise exc.ValueError( "The public key must be exactly {} bytes long".format( self.SIZE ) ) def __bytes__(self) -> bytes: return self._public_key def __hash__(self) -> int: return hash(bytes(self)) def __eq__(self, other: object) -> bool: if not isinstance(other, self.__class__): return False return nacl.bindings.sodium_memcmp(bytes(self), bytes(other)) def __ne__(self, other: object) -> bool: return not (self == other) class PrivateKey(encoding.Encodable, StringFixer): """ Private key for decrypting messages using the Curve25519 algorithm. .. warning:: This **must** be protected and remain secret. Anyone who knows the value of your :class:`~nacl.public.PrivateKey` can decrypt any message encrypted by the corresponding :class:`~nacl.public.PublicKey` :param private_key: The private key used to decrypt messages :param encoder: The encoder class used to decode the given keys :cvar SIZE: The size that the private key is required to be :cvar SEED_SIZE: The size that the seed used to generate the private key is required to be """ SIZE: ClassVar[int] = nacl.bindings.crypto_box_SECRETKEYBYTES SEED_SIZE: ClassVar[int] = nacl.bindings.crypto_box_SEEDBYTES def __init__( self, private_key: bytes, encoder: encoding.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 {} " "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) @classmethod def from_seed( cls, seed: bytes, encoder: encoding.Encoder = encoding.RawEncoder, ) -> "PrivateKey": """ Generate a PrivateKey using a deterministic construction starting from a caller-provided seed .. warning:: The seed **must** be high-entropy; therefore, its generator **must** be a cryptographic quality random function like, for example, :func:`~nacl.utils.random`. .. warning:: The seed **must** be protected and remain secret. Anyone who knows the seed is really in possession of the corresponding PrivateKey. :param seed: The seed used to generate the private key :rtype: :class:`~nacl.public.PrivateKey` """ # decode the seed seed = encoder.decode(seed) # Verify the given seed type and size are correct if not (isinstance(seed, bytes) and len(seed) == cls.SEED_SIZE): raise exc.TypeError( ( "PrivateKey seed must be a {} bytes long " "binary sequence" ).format(cls.SEED_SIZE) ) # generate a raw keypair from the given seed raw_pk, raw_sk = nacl.bindings.crypto_box_seed_keypair(seed) # construct a instance from the raw secret key return cls(raw_sk) def __bytes__(self) -> bytes: return self._private_key def __hash__(self) -> int: return hash((type(self), bytes(self.public_key))) def __eq__(self, other: object) -> bool: if not isinstance(other, self.__class__): return False return self.public_key == other.public_key def __ne__(self, other: object) -> bool: return not (self == other) @classmethod def generate(cls) -> "PrivateKey": """ Generates a random :class:`~nacl.public.PrivateKey` object :rtype: :class:`~nacl.public.PrivateKey` """ return cls(random(PrivateKey.SIZE), encoder=encoding.RawEncoder) _Box = TypeVar("_Box", bound="Box") class Box(encoding.Encodable, StringFixer): """ The Box class boxes and unboxes messages between a pair of keys The ciphertexts generated by :class:`~nacl.public.Box` include a 16 byte authenticator which is checked as part of the decryption. An invalid authenticator will cause the decrypt function to raise an exception. The authenticator is not a signature. Once you've decrypted the message you've demonstrated the ability to create arbitrary valid message, so messages you send are repudiable. For non-repudiable messages, sign them after encryption. :param private_key: :class:`~nacl.public.PrivateKey` used to encrypt and decrypt messages :param public_key: :class:`~nacl.public.PublicKey` used to encrypt and decrypt messages :cvar NONCE_SIZE: The size that the nonce is required to be. """ NONCE_SIZE: ClassVar[int] = nacl.bindings.crypto_box_NONCEBYTES _shared_key: bytes def __init__(self, private_key: PrivateKey, public_key: PublicKey): 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), ) def __bytes__(self) -> bytes: return self._shared_key @classmethod def decode( cls: Type[_Box], encoded: bytes, encoder: Encoder = encoding.RawEncoder ) -> _Box: """ Alternative constructor. Creates a Box from an existing Box's shared key. """ # Create an empty box box: _Box = cls.__new__(cls) # Assign our decoded value to the shared key of the box box._shared_key = encoder.decode(encoded) return box def encrypt( self, plaintext: bytes, nonce: Optional[bytes] = None, encoder: encoding.Encoder = encoding.RawEncoder, ) -> EncryptedMessage: """ Encrypts the plaintext message using the given `nonce` (or generates one randomly if omitted) and returns the ciphertext encoded with the encoder. .. warning:: It is **VITALLY** important that the nonce is a nonce, i.e. it is a number used only once for any given key. If you fail to do this, you compromise the privacy of the messages encrypted. :param plaintext: [:class:`bytes`] The plaintext message to encrypt :param nonce: [:class:`bytes`] The nonce to use in the encryption :param encoder: The encoder to use to encode the ciphertext :rtype: [:class:`nacl.utils.EncryptedMessage`] """ if nonce is None: nonce = random(self.NONCE_SIZE) if len(nonce) != self.NONCE_SIZE: raise exc.ValueError( "The nonce must be exactly %s bytes long" % self.NONCE_SIZE ) ciphertext = nacl.bindings.crypto_box_afternm( plaintext, nonce, self._shared_key, ) encoded_nonce = encoder.encode(nonce) encoded_ciphertext = encoder.encode(ciphertext) return EncryptedMessage._from_parts( encoded_nonce, encoded_ciphertext, encoder.encode(nonce + ciphertext), ) def decrypt( self, ciphertext: bytes, nonce: Optional[bytes] = None, encoder: encoding.Encoder = encoding.RawEncoder, ) -> bytes: """ Decrypts the ciphertext using the `nonce` (explicitly, when passed as a parameter or implicitly, when omitted, as part of the ciphertext) and returns the plaintext message. :param ciphertext: [:class:`bytes`] The encrypted message to decrypt :param nonce: [:class:`bytes`] The nonce used when encrypting the ciphertext :param encoder: The encoder used to decode the ciphertext. :rtype: [:class:`bytes`] """ # Decode our ciphertext ciphertext = encoder.decode(ciphertext) if nonce is None: # If we were given the nonce and ciphertext combined, split them. nonce = ciphertext[: self.NONCE_SIZE] ciphertext = ciphertext[self.NONCE_SIZE :] if len(nonce) != self.NONCE_SIZE: raise exc.ValueError( "The nonce must be exactly %s bytes long" % self.NONCE_SIZE ) plaintext = nacl.bindings.crypto_box_open_afternm( ciphertext, nonce, self._shared_key, ) return plaintext def shared_key(self) -> bytes: """ Returns the Curve25519 shared secret, that can then be used as a key in other symmetric ciphers. .. warning:: It is **VITALLY** important that you use a nonce with your symmetric cipher. If you fail to do this, you compromise the privacy of the messages encrypted. Ensure that the key length of your cipher is 32 bytes. :rtype: [:class:`bytes`] """ return self._shared_key _Key = TypeVar("_Key", PublicKey, PrivateKey) class SealedBox(Generic[_Key], encoding.Encodable, StringFixer): """ The SealedBox class boxes and unboxes messages addressed to a specified key-pair by using ephemeral sender's keypairs, whose private part will be discarded just after encrypting a single plaintext message. The ciphertexts generated by :class:`~nacl.public.SecretBox` include the public part of the ephemeral key before the :class:`~nacl.public.Box` ciphertext. :param recipient_key: a :class:`~nacl.public.PublicKey` used to encrypt messages and derive nonces, or a :class:`~nacl.public.PrivateKey` used to decrypt messages. .. versionadded:: 1.2 """ _public_key: bytes _private_key: Optional[bytes] def __init__(self, recipient_key: _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 __bytes__(self) -> bytes: return self._public_key def encrypt( self, plaintext: bytes, encoder: encoding.Encoder = encoding.RawEncoder, ) -> bytes: """ Encrypts the plaintext message using a random-generated ephemeral keypair and returns a "composed ciphertext", containing both the public part of the keypair and the ciphertext proper, encoded with the encoder. The private part of the ephemeral key-pair will be scrubbed before returning the ciphertext, therefore, the sender will not be able to decrypt the generated ciphertext. :param plaintext: [:class:`bytes`] The plaintext message to encrypt :param encoder: The encoder to use to encode the ciphertext :return bytes: encoded ciphertext """ ciphertext = nacl.bindings.crypto_box_seal(plaintext, self._public_key) encoded_ciphertext = encoder.encode(ciphertext) return encoded_ciphertext def decrypt( self: "SealedBox[PrivateKey]", ciphertext: bytes, encoder: encoding.Encoder = encoding.RawEncoder, ) -> bytes: """ Decrypts the ciphertext using the ephemeral public key enclosed in the ciphertext and the SealedBox private key, returning the plaintext message. :param ciphertext: [:class:`bytes`] The encrypted message to decrypt :param encoder: The encoder used to decode the ciphertext. :return bytes: The original plaintext :raises TypeError: if this SealedBox was created with a :class:`~nacl.public.PublicKey` rather than a :class:`~nacl.public.PrivateKey`. """ # Decode our ciphertext ciphertext = encoder.decode(ciphertext) if self._private_key is None: raise TypeError( "SealedBoxes created with a public key cannot decrypt" ) plaintext = nacl.bindings.crypto_box_seal_open( ciphertext, self._public_key, self._private_key, ) return plaintext PK �#�Zrd$��) ��) _sodium.abi3.sonu ȯ�� ELF >