# Struct elastic_elgamal::group::Generic

source · `pub struct Generic<C>(/* private fields */);`

## Expand description

Generic `Group`

implementation for elliptic curves defined in terms of the traits
from the `elliptic-curve`

crate.

## §Assumptions

- Arithmetic operations required to be constant-time as per
`ScalarOps`

and`ElementOps`

contracts are indeed constant-time.

## Trait Implementations§

source§### impl<C> ElementOps for Generic<C>where
C: CurveArithmetic,
Scalar<C>: Zeroize,
FieldBytesSize<C>: ModulusSize,
ProjectivePoint<C>: ToEncodedPoint<C> + FromEncodedPoint<C>,

### impl<C> ElementOps for Generic<C>where
C: CurveArithmetic,
Scalar<C>: Zeroize,
FieldBytesSize<C>: ModulusSize,
ProjectivePoint<C>: ToEncodedPoint<C> + FromEncodedPoint<C>,

§#### type Element = <C as CurveArithmetic>::ProjectivePoint

#### type Element = <C as CurveArithmetic>::ProjectivePoint

Element of the group. Arithmetic operations requested here (addition among
elements and multiplication by a

`Scalar`

) must be constant-time.source§#### const ELEMENT_SIZE: usize = _

#### const ELEMENT_SIZE: usize = _

Byte size of a serialized

`Self::Element`

.source§#### fn identity() -> Self::Element

#### fn identity() -> Self::Element

Returns the identity of the group (aka point at infinity for EC groups).

source§#### fn is_identity(element: &Self::Element) -> bool

#### fn is_identity(element: &Self::Element) -> bool

Checks if the specified element is the identity.

source§#### fn serialize_element(element: &Self::Element, buffer: &mut [u8])

#### fn serialize_element(element: &Self::Element, buffer: &mut [u8])

source§#### fn deserialize_element(input: &[u8]) -> Option<Self::Element>

#### fn deserialize_element(input: &[u8]) -> Option<Self::Element>

Deserializes an element from

`buffer`

, which is guaranteed to have length
`Self::ELEMENT_SIZE`

. This method returns `None`

if the buffer
does not correspond to a representation of a valid scalar.source§### impl<C> Group for Generic<C>where
C: CurveArithmetic + 'static,
Scalar<C>: Zeroize,
FieldBytesSize<C>: ModulusSize,
ProjectivePoint<C>: ToEncodedPoint<C> + FromEncodedPoint<C>,

### impl<C> Group for Generic<C>where
C: CurveArithmetic + 'static,
Scalar<C>: Zeroize,
FieldBytesSize<C>: ModulusSize,
ProjectivePoint<C>: ToEncodedPoint<C> + FromEncodedPoint<C>,

source§#### fn mul_generator(k: &Self::Scalar) -> Self::Element

#### fn mul_generator(k: &Self::Scalar) -> Self::Element

Multiplies the provided scalar by

`ElementOps::generator()`

. This operation must be
constant-time. Read moresource§#### fn vartime_mul_generator(k: &Self::Scalar) -> Self::Element

#### fn vartime_mul_generator(k: &Self::Scalar) -> Self::Element

Multiplies the provided scalar by

`ElementOps::generator()`

.
Unlike `Self::mul_generator()`

, this operation does not need to be constant-time;
thus, it may employ additional optimizations. Read moresource§#### fn multi_mul<'a, I, J>(scalars: I, elements: J) -> Self::Element

#### fn multi_mul<'a, I, J>(scalars: I, elements: J) -> Self::Element

Multiplies provided

`scalars`

by `elements`

. This operation must be constant-time
w.r.t. the given length of elements. Read moresource§#### fn vartime_double_mul_generator(
k: &Self::Scalar,
k_element: Self::Element,
r: &Self::Scalar
) -> Self::Element

#### fn vartime_double_mul_generator( k: &Self::Scalar, k_element: Self::Element, r: &Self::Scalar ) -> Self::Element

Calculates

`k * k_element + r * G`

, where `G`

is the group generator. This operation
does not need to be constant-time. Read moresource§#### fn vartime_multi_mul<'a, I, J>(scalars: I, elements: J) -> Self::Element

#### fn vartime_multi_mul<'a, I, J>(scalars: I, elements: J) -> Self::Element

Multiplies provided

`scalars`

by `elements`

. Unlike `Self::multi_mul()`

,
this operation does not need to be constant-time; thus, it may employ
additional optimizations. Read moresource§### impl<C> ScalarOps for Generic<C>where
C: CurveArithmetic,
Scalar<C>: Zeroize,

### impl<C> ScalarOps for Generic<C>where
C: CurveArithmetic,
Scalar<C>: Zeroize,

§#### type Scalar = <C as CurveArithmetic>::Scalar

#### type Scalar = <C as CurveArithmetic>::Scalar

Scalar type. As per

`Group`

contract, scalars must form a prime field.
Arithmetic operations on scalars requested here must be constant-time.source§#### const SCALAR_SIZE: usize = <FieldBytesSize<C> as Unsigned>::USIZE

#### const SCALAR_SIZE: usize = <FieldBytesSize<C> as Unsigned>::USIZE

Byte size of a serialized

`Self::Scalar`

.source§#### fn generate_scalar<R: CryptoRng + RngCore>(rng: &mut R) -> Self::Scalar

#### fn generate_scalar<R: CryptoRng + RngCore>(rng: &mut R) -> Self::Scalar

Generates a random scalar based on the provided CSPRNG. This operation
must be constant-time.

source§#### fn invert_scalar(scalar: Self::Scalar) -> Self::Scalar

#### fn invert_scalar(scalar: Self::Scalar) -> Self::Scalar

Inverts the

`scalar`

, which is guaranteed to be non-zero. This operation does not
need to be constant-time.source§#### fn serialize_scalar(scalar: &Self::Scalar, buffer: &mut [u8])

#### fn serialize_scalar(scalar: &Self::Scalar, buffer: &mut [u8])

Serializes the scalar into the provided

`buffer`

, which is guaranteed to have length
`Self::SCALAR_SIZE`

.source§#### fn deserialize_scalar(buffer: &[u8]) -> Option<Self::Scalar>

#### fn deserialize_scalar(buffer: &[u8]) -> Option<Self::Scalar>

Deserializes the scalar from

`buffer`

, which is guaranteed to have length
`Self::SCALAR_SIZE`

. This method returns `None`

if the buffer
does not correspond to a representation of a valid scalar.source§#### fn scalar_from_random_bytes(source: RandomBytesProvider<'_>) -> Self::Scalar

#### fn scalar_from_random_bytes(source: RandomBytesProvider<'_>) -> Self::Scalar

Generates a scalar from a

`source`

of random bytes. This operation must be constant-time.
The `source`

is guaranteed to return any necessary number of bytes. Read moresource§#### fn invert_scalars(scalars: &mut [Self::Scalar])

#### fn invert_scalars(scalars: &mut [Self::Scalar])

Inverts scalars in a batch. This operation does not need to be constant-time. Read more

### impl<C> Copy for Generic<C>

## Auto Trait Implementations§

### impl<C> Freeze for Generic<C>

### impl<C> RefUnwindSafe for Generic<C>where
C: RefUnwindSafe,

### impl<C> Send for Generic<C>where
C: Send,

### impl<C> Sync for Generic<C>where
C: Sync,

### impl<C> Unpin for Generic<C>where
C: Unpin,

### impl<C> UnwindSafe for Generic<C>where
C: UnwindSafe,

## Blanket Implementations§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more