Struct dalek_ff_group::FieldElement

pub struct FieldElement(/* private fields */);

A constant-time implementation of the Ed25519 field.

Implementations

impl FieldElement

pub fn from_square(value: [u8; 32]) -> FieldElement

Interpret the value as a little-endian integer, square it, and reduce it into a FieldElement.

pub fn pow(&self, other: FieldElement) -> FieldElement

Perform an exponentiation.

pub fn sqrt_ratio_i(u: FieldElement, v: FieldElement) -> (Choice, FieldElement)

The square root of u/v, as used for Ed25519 point decoding (RFC 8032 5.1.3) and within Ristretto (5.1 Extracting an Inverse Square Root).

The result is only a valid square root if the Choice is true. RFC 8032 simply fails if there isn’t a square root, leaving any return value undefined. Ristretto explicitly returns 0 or sqrt((SQRT_M1 * u) / v).

Trait Implementations

impl<'a> Add<&'a FieldElement> for FieldElement

type Output = FieldElement

The resulting type after applying the + operator.

fn add(self, other: &'a FieldElement) -> Self::Output

Performs the + operation.

impl Add for FieldElement

type Output = FieldElement

The resulting type after applying the + operator.

fn add(self, other: FieldElement) -> Self::Output

Performs the + operation.

impl<'a> AddAssign<&'a FieldElement> for FieldElement

fn add_assign(&mut self, other: &'a FieldElement)

Performs the += operation.

impl AddAssign for FieldElement

fn add_assign(&mut self, other: FieldElement)

Performs the += operation.

impl Clone for FieldElement

fn clone(&self) -> FieldElement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ConditionallySelectable for FieldElement

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 ConstantTimeEq for FieldElement

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 Debug for FieldElement

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

Formats the value using the given formatter.

impl Default for FieldElement

fn default() -> FieldElement

Returns the “default value” for a type.

impl Field for FieldElement

const ZERO: Self = _

The zero element of the field, the additive identity.

const ONE: Self = _

The one element of the field, the multiplicative identity.

fn random(rng: impl RngCore) -> Self

Returns an element chosen uniformly at random using a user-provided RNG.

fn square(&self) -> Self

Squares this element.

fn double(&self) -> Self

Doubles this element.

fn invert(&self) -> CtOption<Self>

Computes the multiplicative inverse of this element, failing if the element is zero.

fn sqrt(&self) -> CtOption<Self>

Returns the square root of the field element, if it is quadratic residue.

fn sqrt_ratio(u: &FieldElement, v: &FieldElement) -> (Choice, FieldElement)

Computes:

fn is_zero(&self) -> Choice

Returns true iff this element is zero.

fn is_zero_vartime(&self) -> bool

Returns true iff this element is zero.

fn cube(&self) -> Self

Cubes this element.

fn sqrt_alt(&self) -> (Choice, Self)

Equivalent to Self::sqrt_ratio(self, one()).

fn pow<S>(&self, exp: S) -> Self

where S: AsRef<[u64]>,

Exponentiates self by exp, where exp is a little-endian order integer exponent.

fn pow_vartime<S>(&self, exp: S) -> Self

where S: AsRef<[u64]>,

Exponentiates self by exp, where exp is a little-endian order integer exponent.

impl From<u128> for FieldElement

fn from(a: u128) -> FieldElement

Converts to this type from the input type.

impl From<u16> for FieldElement

fn from(a: u16) -> FieldElement

Converts to this type from the input type.

impl From<u32> for FieldElement

fn from(a: u32) -> FieldElement

Converts to this type from the input type.

impl From<u64> for FieldElement

fn from(a: u64) -> FieldElement

Converts to this type from the input type.

impl From<u8> for FieldElement

fn from(a: u8) -> FieldElement

Converts to this type from the input type.

impl<'a> Mul<&'a FieldElement> for FieldElement

type Output = FieldElement

The resulting type after applying the * operator.

fn mul(self, other: &'a FieldElement) -> Self::Output

Performs the * operation.

impl Mul for FieldElement

type Output = FieldElement

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> MulAssign<&'a FieldElement> for FieldElement

fn mul_assign(&mut self, other: &'a FieldElement)

Performs the *= operation.

impl MulAssign for FieldElement

fn mul_assign(&mut self, other: FieldElement)

Performs the *= operation.

impl<'a> Neg for &'a FieldElement

type Output = FieldElement

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for FieldElement

type Output = FieldElement

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for FieldElement

fn eq(&self, other: &FieldElement) -> 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 PrimeField for FieldElement

const MODULUS: &'static str = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed"

Modulus of the field written as a string for debugging purposes.

const NUM_BITS: u32 = 255u32

How many bits are needed to represent an element of this field.

const CAPACITY: u32 = 254u32

How many bits of information can be reliably stored in the field element.

const TWO_INV: Self = _

Inverse of $2$ in the field.

const MULTIPLICATIVE_GENERATOR: Self = _

A fixed multiplicative generator of modulus - 1 order. This element must also be a quadratic nonresidue.

const S: u32 = 2u32

An integer s satisfying the equation 2^s * t = modulus - 1 with t odd.

const ROOT_OF_UNITY: Self = _

The 2^s root of unity.

const ROOT_OF_UNITY_INV: Self = _

Inverse of Self::ROOT_OF_UNITY.

const DELTA: Self = _

Generator of the t-order multiplicative subgroup.

type Repr = [u8; 32]

The prime field can be converted back and forth into this binary representation.

fn from_repr(bytes: [u8; 32]) -> CtOption<Self>

Attempts to convert a byte representation of a field element into an element of this prime field, failing if the input is not canonical (is not smaller than the field’s modulus).

fn to_repr(&self) -> [u8; 32]

Converts an element of the prime field into the standard byte representation for this field.

fn is_odd(&self) -> Choice

Returns true iff this element is odd.

fn from_u128(num: u128) -> Self

Obtains a field element congruent to the integer v.

fn from_str_vartime(s: &str) -> Option<Self>

Interpret a string of numbers as a (congruent) prime field element. Does not accept unnecessary leading zeroes or a blank string.

fn from_repr_vartime(repr: Self::Repr) -> Option<Self>

Attempts to convert a byte representation of a field element into an element of this prime field, failing if the input is not canonical (is not smaller than the field’s modulus).

fn is_even(&self) -> Choice

Returns true iff this element is even.

impl PrimeFieldBits for FieldElement

type ReprBits = [u8; 32]

The backing store for a bit representation of a prime field element.

fn to_le_bits(&self) -> FieldBits<Self::ReprBits>

Converts an element of the prime field into a little-endian sequence of bits.

fn char_le_bits() -> FieldBits<Self::ReprBits>

Returns the bits of the field characteristic (the modulus) in little-endian order.

impl<'a> Product<&'a FieldElement> for FieldElement

fn product<I: Iterator<Item = &'a FieldElement>>(iter: I) -> FieldElement

Takes an iterator and generates Self from the elements by multiplying the items.

impl Product for FieldElement

fn product<I: Iterator<Item = FieldElement>>(iter: I) -> FieldElement

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'a> Sub<&'a FieldElement> for FieldElement

type Output = FieldElement

The resulting type after applying the - operator.

fn sub(self, other: &'a FieldElement) -> Self::Output

Performs the - operation.

impl Sub for FieldElement

type Output = FieldElement

The resulting type after applying the - operator.

fn sub(self, other: FieldElement) -> Self::Output

Performs the - operation.

impl<'a> SubAssign<&'a FieldElement> for FieldElement

fn sub_assign(&mut self, other: &'a FieldElement)

Performs the -= operation.

impl SubAssign for FieldElement

fn sub_assign(&mut self, other: FieldElement)

Performs the -= operation.

impl<'a> Sum<&'a FieldElement> for FieldElement

fn sum<I: Iterator<Item = &'a FieldElement>>(iter: I) -> FieldElement

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Sum for FieldElement

fn sum<I: Iterator<Item = FieldElement>>(iter: I) -> FieldElement

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Copy for FieldElement

impl Eq for FieldElement

impl StructuralPartialEq for FieldElement

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes