Struct dryoc::sign::SignedMessage

pub struct SignedMessage<Signature: ByteArray<CRYPTO_SIGN_BYTES>, Message: Bytes> { /* private fields */ }

A signed message, for use with SigningKeyPair.

Implementations

impl<Signature: ByteArray<CRYPTO_SIGN_BYTES>, Message: Bytes> SignedMessage<Signature, Message>

pub fn verify<PublicKey: ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES>>(
    &self,
    public_key: &PublicKey
) -> Result<(), Error>

Verifies that this signed message is valid for public_key.

impl<'a, Signature: ByteArray<CRYPTO_SIGN_BYTES> + TryFrom<&'a [u8]>, Message: Bytes + From<&'a [u8]>> SignedMessage<Signature, Message>

pub fn from_bytes(bytes: &'a [u8]) -> Result<Self, Error>

Initializes a SignedMessage from a slice. Expects the first CRYPTO_SIGN_BYTES bytes to contain the message signature, with the remaining bytes containing the message.

impl<Signature: ByteArray<CRYPTO_SIGN_BYTES>, Message: Bytes> SignedMessage<Signature, Message>

pub fn from_parts(signature: Signature, message: Message) -> Self

Returns a new box with tag, data and (optional) ephemeral_pk, consuming each.

pub fn to_vec(&self) -> Vec<u8>

Copies self into a new Vec

pub fn into_parts(self) -> (Signature, Message)

Moves the tag, data, and (optional) ephemeral public key out of this instance, returning them as a tuple.

pub fn to_bytes<Bytes: NewBytes + ResizableBytes>(&self) -> Bytes

Copies self into the target. Can be used with protected memory.

Trait Implementations

impl<Signature: Clone + ByteArray<CRYPTO_SIGN_BYTES>, Message: Clone + Bytes> Clone for SignedMessage<Signature, Message>

fn clone(&self) -> SignedMessage<Signature, Message>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Signature: Debug + ByteArray<CRYPTO_SIGN_BYTES>, Message: Debug + Bytes> Debug for SignedMessage<Signature, Message>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, Signature, Message> Deserialize<'de> for SignedMessage<Signature, Message>where
    Signature: Deserialize<'de> + ByteArray<CRYPTO_SIGN_BYTES>,
    Message: Deserialize<'de> + Bytes,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Signature: ByteArray<CRYPTO_SIGN_BYTES>, Message: Bytes> PartialEq<SignedMessage<Signature, Message>> for SignedMessage<Signature, Message>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Signature, Message> Serialize for SignedMessage<Signature, Message>where
    Signature: Serialize + ByteArray<CRYPTO_SIGN_BYTES>,
    Message: Serialize + Bytes,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Signature, Message> Zeroize for SignedMessage<Signature, Message>where
    Signature: Zeroize + ByteArray<CRYPTO_SIGN_BYTES>,
    Message: Zeroize + Bytes,

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.