Struct NonZeroScalar 

#[repr(transparent)]
pub struct NonZeroScalar<C>
where
    C: CurveArithmetic,
{
    scalar: Scalar<C>,
}

Non-zero scalar type.

This type ensures that its value is not zero, ala core::num::NonZero*. To do this, the generic S type must impl both Default and ConstantTimeEq, with the requirement that S::default() returns 0.

In the context of ECC, it’s useful for ensuring that scalar multiplication cannot result in the point at infinity.

Fields

scalar: Scalar<C>

Implementations

impl<C> NonZeroScalar<C>

where C: CurveArithmetic,

pub fn new(scalar: Scalar<C>) -> CtOption<Self>

Create a NonZeroScalar from a scalar.

pub fn from_repr(repr: FieldBytes<C>) -> CtOption<Self>

Decode a NonZeroScalar from a big endian-serialized field element.

pub fn from_uint(uint: C::Uint) -> CtOption<Self>

Create a NonZeroScalar from a C::Uint.

pub fn cast_array_as_inner<const N: usize>( scalars: &[Self; N], ) -> &[Scalar<C>; N]

Transform array reference containing NonZeroScalars to an array reference to the inner scalar type.

pub fn cast_slice_as_inner(scalars: &[Self]) -> &[Scalar<C>]

Transform slice containing NonZeroScalars to a slice of the inner scalar type.

pub fn random<R: CryptoRng + ?Sized>(rng: &mut R) -> Self

👎Deprecated since 0.14.0: use the Generate trait instead

Deprecated: Generate a random NonZeroScalar.

Trait Implementations

impl<C> AsRef<<C as CurveArithmetic>::Scalar> for NonZeroScalar<C>

where C: CurveArithmetic,

fn as_ref(&self) -> &Scalar<C>

Converts this type into a shared reference of the (usually inferred) input type.

impl<C> Clone for NonZeroScalar<C>

where C: CurveArithmetic + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C> ConditionallySelectable for NonZeroScalar<C>

where C: CurveArithmetic,

fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

fn conditional_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign other to self, according to choice.

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves.

impl<C> ConstantTimeEq for NonZeroScalar<C>

where C: CurveArithmetic,

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<C: CurveArithmetic> Debug for NonZeroScalar<C>

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

Formats the value using the given formatter.

impl<C> Deref for NonZeroScalar<C>

where C: CurveArithmetic,

type Target = <C as CurveArithmetic>::Scalar

The resulting type after dereferencing.

fn deref(&self) -> &Scalar<C>

Dereferences the value.

impl<C> Display for NonZeroScalar<C>

where C: CurveArithmetic,

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

Formats the value using the given formatter.

impl<C> From<&NonZeroScalar<C>> for FieldBytes<C>

where C: CurveArithmetic,

fn from(scalar: &NonZeroScalar<C>) -> FieldBytes<C>

Converts to this type from the input type.

impl<C> From<&NonZeroScalar<C>> for ScalarValue<C>

where C: CurveArithmetic,

fn from(scalar: &NonZeroScalar<C>) -> ScalarValue<C>

Converts to this type from the input type.

impl<C> From<&NonZeroScalar<C>> for SecretKey<C>

where C: CurveArithmetic,

Available on crate feature arithmetic only.

fn from(scalar: &NonZeroScalar<C>) -> SecretKey<C>

Converts to this type from the input type.

impl<C> From<&SecretKey<C>> for NonZeroScalar<C>

where C: CurveArithmetic,

fn from(sk: &SecretKey<C>) -> NonZeroScalar<C>

Converts to this type from the input type.

impl<C> From<NonZeroScalar<C>> for FieldBytes<C>

where C: CurveArithmetic,

fn from(scalar: NonZeroScalar<C>) -> FieldBytes<C>

Converts to this type from the input type.

impl<C> From<NonZeroScalar<C>> for ScalarValue<C>

where C: CurveArithmetic,

fn from(scalar: NonZeroScalar<C>) -> ScalarValue<C>

Converts to this type from the input type.

impl<C> From<NonZeroScalar<C>> for SecretKey<C>

where C: CurveArithmetic,

Available on crate feature arithmetic only.

fn from(scalar: NonZeroScalar<C>) -> SecretKey<C>

Converts to this type from the input type.

impl<C> From<SecretKey<C>> for NonZeroScalar<C>

where C: CurveArithmetic,

fn from(sk: SecretKey<C>) -> NonZeroScalar<C>

Converts to this type from the input type.

impl<C> FromStr for NonZeroScalar<C>

where C: CurveArithmetic,

type Err = Error

The associated error which can be returned from parsing.

fn from_str(hex: &str) -> Result<Self, Error>

Parses a string s to return a value of this type.

impl<C> Generate for NonZeroScalar<C>

where C: CurveArithmetic,

fn try_generate_from_rng<R: TryCryptoRng + ?Sized>( rng: &mut R, ) -> Result<Self, R::Error>

Generate random key using the provided TryCryptoRng.

fn generate_from_rng<R>(rng: &mut R) -> Self

where R: CryptoRng + ?Sized,

Generate random key using the provided CryptoRng.

fn try_generate() -> Result<Self, Error>

Randomly generate a value of this type using the system’s ambient cryptographically secure random number generator.

fn generate() -> Self

Randomly generate a value of this type using the system’s ambient cryptographically secure random number generator.

impl<C> Invert for NonZeroScalar<C>

where C: CurveArithmetic, Scalar<C>: Invert<Output = CtOption<Scalar<C>>>,

type Output = NonZeroScalar<C>

Output of the inversion.

fn invert(&self) -> Self

Computes the inverse.

fn invert_vartime(&self) -> Self::Output

Computes the inverse in variable-time.

impl<C> IsHigh for NonZeroScalar<C>

where C: CurveArithmetic,

fn is_high(&self) -> Choice

Is this scalar greater than n / 2?

impl<C> LowerHex for NonZeroScalar<C>

where C: CurveArithmetic,

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

Formats the value using the given formatter.

impl<C, P> Mul<&NonIdentity<P>> for &NonZeroScalar<C>

where C: CurveArithmetic, for<'a> &'a NonIdentity<P>: Mul<&'a NonZeroScalar<C>, Output = NonIdentity<P>>,

type Output = NonIdentity<P>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonIdentity<P>) -> Self::Output

Performs the * operation.

impl<C, P> Mul<&NonIdentity<P>> for NonZeroScalar<C>

where C: CurveArithmetic, for<'a> &'a NonIdentity<P>: Mul<NonZeroScalar<C>, Output = NonIdentity<P>>,

type Output = NonIdentity<P>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonIdentity<P>) -> Self::Output

Performs the * operation.

impl<C, P> Mul<&NonZeroScalar<C>> for &NonIdentity<P>

where C: CurveArithmetic, P: Copy + Mul<Scalar<C>, Output = P>,

type Output = NonIdentity<P>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroScalar<C>) -> Self::Output

Performs the * operation.

impl<C, P> Mul<&NonZeroScalar<C>> for NonIdentity<P>

where C: CurveArithmetic, P: Copy + Mul<Scalar<C>, Output = P>,

type Output = NonIdentity<P>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZeroScalar<C>) -> Self::Output

Performs the * operation.

impl<C> Mul<&NonZeroScalar<C>> for NonZeroScalar<C>

where C: PrimeCurve + CurveArithmetic,

type Output = NonZeroScalar<C>

The resulting type after applying the * operator.

fn mul(self, other: &Self) -> Self

Performs the * operation.

impl<C, P> Mul<NonIdentity<P>> for &NonZeroScalar<C>

where C: CurveArithmetic, for<'a> NonIdentity<P>: Mul<&'a NonZeroScalar<C>, Output = NonIdentity<P>>,

type Output = NonIdentity<P>

The resulting type after applying the * operator.

fn mul(self, rhs: NonIdentity<P>) -> Self::Output

Performs the * operation.

impl<C, P> Mul<NonIdentity<P>> for NonZeroScalar<C>

where C: CurveArithmetic, NonIdentity<P>: Mul<NonZeroScalar<C>, Output = NonIdentity<P>>,

type Output = NonIdentity<P>

The resulting type after applying the * operator.

fn mul(self, rhs: NonIdentity<P>) -> Self::Output

Performs the * operation.

impl<C, P> Mul<NonZeroScalar<C>> for &NonIdentity<P>

where C: CurveArithmetic, P: Copy + Mul<Scalar<C>, Output = P>,

type Output = NonIdentity<P>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroScalar<C>) -> Self::Output

Performs the * operation.

impl<C, P> Mul<NonZeroScalar<C>> for NonIdentity<P>

where C: CurveArithmetic, P: Copy + Mul<Scalar<C>, Output = P>,

type Output = NonIdentity<P>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZeroScalar<C>) -> Self::Output

Performs the * operation.

impl<C> Mul for NonZeroScalar<C>

where C: PrimeCurve + CurveArithmetic,

type Output = NonZeroScalar<C>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl<C> MulAssign for NonZeroScalar<C>

where C: PrimeCurve + CurveArithmetic,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<C> Neg for NonZeroScalar<C>

where C: CurveArithmetic,

type Output = NonZeroScalar<C>

The resulting type after applying the - operator.

fn neg(self) -> NonZeroScalar<C>

Performs the unary - operation.

impl<C> PartialEq for NonZeroScalar<C>

where C: CurveArithmetic,

fn eq(&self, other: &Self) -> 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, T> Reduce<T> for NonZeroScalar<C>

where C: CurveArithmetic, Scalar<C>: ReduceNonZero<T>,

fn reduce(n: &T) -> Self

Reduces self modulo Modulus.

impl<C, T> ReduceNonZero<T> for NonZeroScalar<C>

where C: CurveArithmetic, Scalar<C>: ReduceNonZero<T>,

fn reduce_nonzero(n: &T) -> Self

Perform a modular reduction, returning a field element.

impl<C> TryFrom<&[u8]> for NonZeroScalar<C>

where C: CurveArithmetic,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Self, Error>

Performs the conversion.

impl<C> UpperHex for NonZeroScalar<C>

where C: CurveArithmetic,

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

Formats the value using the given formatter.

impl<C> Zeroize for NonZeroScalar<C>

where C: CurveArithmetic,

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.

impl<C> Copy for NonZeroScalar<C>

where C: CurveArithmetic,

impl<C> Eq for NonZeroScalar<C>

where C: CurveArithmetic,