Struct Cipher 

pub struct Cipher<C>(pub C, pub C)
where
    C: Curve;

Encrypted message.

Tuple Fields

0: C

1: C

Implementations

impl<C> Cipher<C>

where C: Curve,

pub fn from_bytes<R>(bytes: &mut R) -> Result<Cipher<C>, Error>

where R: ReadBytesExt,

Construct a cipher from a slice of bytes. only use if you know that the bytes are an encoding fo a cipher A Result whose okay value is a cipher key or whose error value is an ElgamalError wrapping the internal error that occurred.

pub fn generate<T>(csprng: &mut T) -> Cipher<C>

where T: Rng,

Generate a random cipher.

pub fn combine(&self, other: &Cipher<C>) -> Cipher<C>

Combine two ciphers together by adding the individual components.

This does not check that both ciphers were produced with the same public key, that is the responsibility of the caller. In case ciphers were produced with different public keys, their combination is still mathematically valid, however it does not have meaning.

pub fn scale(&self, e: &<C as Curve>::Scalar) -> Cipher<C>

Scale the ciphertext by the given scalar. If the input is encryption of m, then the result is the encryption of m^e, where e is the given exponent.

pub fn scale_u64(&self, e: u64) -> Cipher<C>

Same as scale, but provided for convenience.

Trait Implementations

impl<C> Clone for Cipher<C>

where C: Clone + Curve,

fn clone(&self) -> Cipher<C>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> Debug for Cipher<C>

where C: Debug + Curve,

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

Formats the value using the given formatter.

impl<C> Deserial for Cipher<C>

where C: Curve,

fn deserial<GenericReaderType>( source: &mut GenericReaderType, ) -> Result<Cipher<C>, Error>

where GenericReaderType: ReadBytesExt,

impl<'de, C> Deserialize<'de> for Cipher<C>

where C: Curve,

fn deserialize<GenericSerializerType>( deserializer: GenericSerializerType, ) -> Result<Cipher<C>, <GenericSerializerType as Deserializer<'de>>::Error>

where GenericSerializerType: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C> PartialEq for Cipher<C>

where C: PartialEq + Curve,

fn eq(&self, other: &Cipher<C>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<C> Serial for Cipher<C>

where C: Curve,

fn serial<GenericBufferType>(&self, out: &mut GenericBufferType)

where GenericBufferType: Buffer,

impl<C> Serialize for Cipher<C>

where C: Curve,

fn serialize<GenericSerializerType>( &self, serializer: GenericSerializerType, ) -> Result<<GenericSerializerType as Serializer>::Ok, <GenericSerializerType as Serializer>::Error>

where GenericSerializerType: Serializer,

Serialize this value into the given Serde serializer.

impl<C> Copy for Cipher<C>

where C: Copy + Curve,

impl<C> Eq for Cipher<C>

where C: Eq + Curve,

impl<C> StructuralPartialEq for Cipher<C>

where C: Curve,