Struct Generic

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

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

impl<C> Clone for Generic<C>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for Generic<C>

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

Formats the value using the given formatter.

impl<C> ElementOps for Generic<C>

where C: CurveArithmetic, Scalar<C>: Zeroize, FieldBytesSize<C>: ModulusSize, ProjectivePoint<C>: ToEncodedPoint<C> + FromEncodedPoint<C>,

const ELEMENT_SIZE: usize = _

Byte size of a serialized Self::Element.

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.

fn identity() -> Self::Element

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

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

Checks if the specified element is the identity.

fn generator() -> Self::Element

Returns the agreed-upon generator of the group.

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

Serializes element into the provided buffer, which is guaranteed to have length Self::ELEMENT_SIZE.

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.

impl<C> Group for Generic<C>

where C: CurveArithmetic + 'static, Scalar<C>: Zeroize, FieldBytesSize<C>: ModulusSize, ProjectivePoint<C>: ToEncodedPoint<C> + FromEncodedPoint<C>,

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

Multiplies the provided scalar by ElementOps::generator(). This operation must be constant-time.

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.

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

where I: IntoIterator<Item = &'a Self::Scalar>, J: IntoIterator<Item = Self::Element>,

Multiplies provided scalars by elements. This operation must be constant-time w.r.t. the given length of elements.

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.

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

where I: IntoIterator<Item = &'a Self::Scalar>, J: IntoIterator<Item = 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.

impl<C> ScalarOps for Generic<C>

where C: CurveArithmetic, Scalar<C>: Zeroize,

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

Byte size of a serialized Self::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.

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.

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.

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.

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.

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.

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

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

impl<C> Copy for Generic<C>