Struct Ghash128 

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

The binary field GF(2^128) modulo x^128 + x^7 + x^2 + x + 1.

Bit i stores the coefficient of x^i. Every 128-bit pattern is a distinct field element.

Hardware carryless multiplication operates directly on this representation. The tower representation instead provides byte-aligned subfields.

Inversion and conversions to or from the tower use operand-indexed tables. They are not constant-time for secret inputs.

NIST GCM blocks use the opposite coefficient order. Reverse all 128 bits of a big-endian block integer before interpreting it here.

Implementations

impl Ghash128

pub fn from_tower_vec(values: Vec<BinaryField128>) -> Vec<Self>

A whole table of tower elements, seen in the polynomial basis, in the table’s own buffer.

Each entry becomes what From makes of it.

Chunks of the table convert in parallel, a block at a time where the build has the blocked kernel crate::poly_basis::from_tower_slice describes.

pub fn try_apply_linear_map_into( images: &[Self; 128], input: &[BinaryField128], output: &mut [Self], ) -> bool

Tries to apply an arbitrary F_2-linear map, given by its column images, to a batch.

images[j] is the output image of input bit j, in the little-endian coordinate order. The map need not be a change of basis: any linear map, invertible or not, is applied to the raw bits of each input. A short or unsupported target returns false without touching output; equal lengths are required before that dispatch so an invalid call cannot be mistaken for a refusal.

pub const fn from_le_bytes(bytes: [u8; 16]) -> Self

Construct a field element from its little-endian byte representation.

Every byte string of this length is a valid element.

pub fn dot_powers_of_x(values: &[Self]) -> Self

Combine values against the successive powers of the indeterminate.

    sum_k values_k * x^k

In this representation a power of the indeterminate shifts the coefficients up.

So the combination can be shifts and exclusive ors, with no multiplication at all.

Either way the modulus is folded in once at the end, not once per term.

Which route is faster depends on the target.

A hardware carryless multiply turns each term into one cheap product, and beats the shifts.

Without one a product costs sixteen integer multiplies, and the shifts win by an order of magnitude.

The choice is made at compile time from the same flag the rest of the crate reads.

Panics

Panics on more values than the field has bits.

That ceiling is where the last shift would leave the word.

pub fn invert_or_zero(self) -> Self

The inverse of this element, with zero sent to zero.

On a carryless-multiply target the addition chain runs whatever the operand is, so its cost says nothing about the value. The operand-indexed tables it uses still make it variable-time.

Trait Implementations

impl Add for Ghash128

type Output = Ghash128

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl Add<BinaryField8> for Ghash128

type Output = Ghash128

The resulting type after applying the + operator.

fn add(self, rhs: BinaryField8) -> Self

Performs the + operation.

impl Add<BinaryField16> for Ghash128

type Output = Ghash128

The resulting type after applying the + operator.

fn add(self, rhs: BinaryField16) -> Self

Performs the + operation.

impl Add<BinaryField32> for Ghash128

type Output = Ghash128

The resulting type after applying the + operator.

fn add(self, rhs: BinaryField32) -> Self

Performs the + operation.

impl Add<BinaryField64> for Ghash128

type Output = Ghash128

The resulting type after applying the + operator.

fn add(self, rhs: BinaryField64) -> Self

Performs the + operation.

impl Add<BinaryField128> for Ghash128

fn add(self, rhs: BinaryField128) -> Self

The sum, in the polynomial basis.

The tower operand is converted first, which costs sixteen table lookups.

type Output = Ghash128

The resulting type after applying the + operator.

impl Add<Gf2> for Ghash128

type Output = Ghash128

The resulting type after applying the + operator.

fn add(self, rhs: Gf2) -> Self

Performs the + operation.

impl Add<Ghash128> for BinaryField8

type Output = Ghash128

The resulting type after applying the + operator.

fn add(self, rhs: Ghash128) -> Self::Output

Performs the + operation.

impl Add<Ghash128> for BinaryField16

type Output = Ghash128

The resulting type after applying the + operator.

fn add(self, rhs: Ghash128) -> Self::Output

Performs the + operation.

impl Add<Ghash128> for BinaryField32

type Output = Ghash128

The resulting type after applying the + operator.

fn add(self, rhs: Ghash128) -> Self::Output

Performs the + operation.

impl Add<Ghash128> for BinaryField64

type Output = Ghash128

The resulting type after applying the + operator.

fn add(self, rhs: Ghash128) -> Self::Output

Performs the + operation.

impl Add<Ghash128> for Gf2

type Output = Ghash128

The resulting type after applying the + operator.

fn add(self, rhs: Ghash128) -> Self::Output

Performs the + operation.

impl<T: Into<Self>> AddAssign<T> for Ghash128

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl Algebra<BinaryField8> for Ghash128

fn quadratic_extension_square(a: &[Self; 2], w: F) -> [Self; 2]

Square a[0] + a[1] X modulo X^2 - w.

fn mixed_dot_product<const N: usize>(a: &[Self; N], f: &[F; N]) -> Self

where F: Dup,

Dot product between algebra elements and base field scalars.

const BATCHED_LC_CHUNK: usize = 8

Optimal chunk size for batched_linear_combination.

fn batched_linear_combination(values: &[Self], coeffs: &[F]) -> Self

where F: Dup,

Runtime-length linear combination: Σ values[i] * coeffs[i].

impl Algebra<BinaryField16> for Ghash128

fn quadratic_extension_square(a: &[Self; 2], w: F) -> [Self; 2]

Square a[0] + a[1] X modulo X^2 - w.

fn mixed_dot_product<const N: usize>(a: &[Self; N], f: &[F; N]) -> Self

where F: Dup,

Dot product between algebra elements and base field scalars.

const BATCHED_LC_CHUNK: usize = 8

Optimal chunk size for batched_linear_combination.

fn batched_linear_combination(values: &[Self], coeffs: &[F]) -> Self

where F: Dup,

Runtime-length linear combination: Σ values[i] * coeffs[i].

impl Algebra<BinaryField32> for Ghash128

fn quadratic_extension_square(a: &[Self; 2], w: F) -> [Self; 2]

Square a[0] + a[1] X modulo X^2 - w.

fn mixed_dot_product<const N: usize>(a: &[Self; N], f: &[F; N]) -> Self

where F: Dup,

Dot product between algebra elements and base field scalars.

const BATCHED_LC_CHUNK: usize = 8

Optimal chunk size for batched_linear_combination.

fn batched_linear_combination(values: &[Self], coeffs: &[F]) -> Self

where F: Dup,

Runtime-length linear combination: Σ values[i] * coeffs[i].

impl Algebra<BinaryField64> for Ghash128

fn quadratic_extension_square(a: &[Self; 2], w: F) -> [Self; 2]

Square a[0] + a[1] X modulo X^2 - w.

fn mixed_dot_product<const N: usize>(a: &[Self; N], f: &[F; N]) -> Self

where F: Dup,

Dot product between algebra elements and base field scalars.

const BATCHED_LC_CHUNK: usize = 8

Optimal chunk size for batched_linear_combination.

fn batched_linear_combination(values: &[Self], coeffs: &[F]) -> Self

where F: Dup,

Runtime-length linear combination: Σ values[i] * coeffs[i].

impl Algebra<BinaryField128> for Ghash128

fn quadratic_extension_square(a: &[Self; 2], w: F) -> [Self; 2]

Square a[0] + a[1] X modulo X^2 - w.

fn mixed_dot_product<const N: usize>(a: &[Self; N], f: &[F; N]) -> Self

where F: Dup,

Dot product between algebra elements and base field scalars.

const BATCHED_LC_CHUNK: usize = 8

Optimal chunk size for batched_linear_combination.

fn batched_linear_combination(values: &[Self], coeffs: &[F]) -> Self

where F: Dup,

Runtime-length linear combination: Σ values[i] * coeffs[i].

impl Algebra<Gf2> for Ghash128

fn quadratic_extension_square(a: &[Self; 2], w: F) -> [Self; 2]

Square a[0] + a[1] X modulo X^2 - w.

fn mixed_dot_product<const N: usize>(a: &[Self; N], f: &[F; N]) -> Self

where F: Dup,

Dot product between algebra elements and base field scalars.

const BATCHED_LC_CHUNK: usize = 8

Optimal chunk size for batched_linear_combination.

fn batched_linear_combination(values: &[Self], coeffs: &[F]) -> Self

where F: Dup,

Runtime-length linear combination: Σ values[i] * coeffs[i].

impl Clone for Ghash128

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Ghash128

impl Debug for Ghash128

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

Formats the value using the given formatter.

impl Default for Ghash128

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Ghash128

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Ghash128

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

Formats the value using the given formatter.

impl Distribution<Ghash128> for StandardUniform

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Ghash128

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl Div for Ghash128

type Output = Ghash128

The resulting type after applying the / operator.

fn div(self, rhs: Ghash128) -> Self

Performs the / operation.

impl DivAssign for Ghash128

fn div_assign(&mut self, rhs: Ghash128)

Performs the /= operation.

impl Eq for Ghash128

impl Field for Ghash128

fn try_inverse(&self) -> Option<Self>

Invert through precomputed squaring maps on carryless-multiply targets. The software backend instead uses the recursive tower norm.

The operand-indexed tables make this operation variable-time.

fn bits() -> usize

An element of GF(2^n) is exactly n bits wide.

fn interpolation_node(i: usize) -> Self

The enumeration by bit pattern.

The coordinates of the returned element over GF(2) are the bits of the index. A pointer is never 128 bits wide, so every index is in range.

const GENERATOR: Self

A generator of this field’s multiplicative group.

type Packing = Ghash128

fn try_sqrt(&self) -> Option<Self>

A square root of this field element, if one exists.

fn order() -> BigUint

The number of elements in the field.

const BENEFITS_FROM_LOCKSTEP_EVALUATION: bool = false

Whether evaluating multiple packed vectors of this field in lockstep (to overlap independent dependency chains and hide packed-multiplication latency) is expected to help throughput for this field.

fn is_zero(&self) -> bool

Check if the given field element is equal to the unique additive identity (ZERO).

fn is_one(&self) -> bool

Check if the given field element is equal to the unique multiplicative identity (ONE).

fn inverse(&self) -> Self

The multiplicative inverse of this field element.

fn add_slices(slice_1: &mut [Self], slice_2: &[Self])

Add two slices of field elements together, returning the result in the first slice.

fn batched_columnwise_dot_product<EF, R, I, const N: usize>( acc: &mut [<EF as ExtensionField<Self>>::ExtensionPacking], items: I, )

where EF: ExtensionField<Self>, R: Iterator<Item = Self::Packing>, I: Iterator<Item = (R, [EF; N])>,

Accumulate acc[c * N + j] += scales[j] * row[c] over a stream of packed rows.

impl From<BinaryField8> for Ghash128

fn from(x: BinaryField8) -> Self

Converts to this type from the input type.

impl From<BinaryField16> for Ghash128

fn from(x: BinaryField16) -> Self

Converts to this type from the input type.

impl From<BinaryField32> for Ghash128

fn from(x: BinaryField32) -> Self

Converts to this type from the input type.

impl From<BinaryField64> for Ghash128

fn from(x: BinaryField64) -> Self

Converts to this type from the input type.

impl From<BinaryField128> for Ghash128

fn from(x: BinaryField128) -> Self

The same field element, seen in the polynomial basis.

impl From<Gf2> for Ghash128

fn from(x: Gf2) -> Self

GF(2) is the prime subfield, embedded as {ZERO, ONE}.

impl From<Ghash128> for BinaryField128

fn from(x: Ghash128) -> Self

The same field element, seen in the tower basis.

impl Hash for Ghash128

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul for Ghash128

type Output = Ghash128

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<BinaryField8> for Ghash128

type Output = Ghash128

The resulting type after applying the * operator.

fn mul(self, rhs: BinaryField8) -> Self

Performs the * operation.

impl Mul<BinaryField16> for Ghash128

type Output = Ghash128

The resulting type after applying the * operator.

fn mul(self, rhs: BinaryField16) -> Self

Performs the * operation.

impl Mul<BinaryField32> for Ghash128

type Output = Ghash128

The resulting type after applying the * operator.

fn mul(self, rhs: BinaryField32) -> Self

Performs the * operation.

impl Mul<BinaryField64> for Ghash128

type Output = Ghash128

The resulting type after applying the * operator.

fn mul(self, rhs: BinaryField64) -> Self

Performs the * operation.

impl Mul<BinaryField128> for Ghash128

fn mul(self, rhs: BinaryField128) -> Self

The product, in the polynomial basis.

The tower operand is converted first, which costs sixteen table lookups.

type Output = Ghash128

The resulting type after applying the * operator.

impl Mul<Gf2> for Ghash128

type Output = Ghash128

The resulting type after applying the * operator.

fn mul(self, rhs: Gf2) -> Self

Performs the * operation.

impl Mul<Ghash128> for BinaryField8

type Output = Ghash128

The resulting type after applying the * operator.

fn mul(self, rhs: Ghash128) -> Self::Output

Performs the * operation.

impl Mul<Ghash128> for BinaryField16

type Output = Ghash128

The resulting type after applying the * operator.

fn mul(self, rhs: Ghash128) -> Self::Output

Performs the * operation.

impl Mul<Ghash128> for BinaryField32

type Output = Ghash128

The resulting type after applying the * operator.

fn mul(self, rhs: Ghash128) -> Self::Output

Performs the * operation.

impl Mul<Ghash128> for BinaryField64

type Output = Ghash128

The resulting type after applying the * operator.

fn mul(self, rhs: Ghash128) -> Self::Output

Performs the * operation.

impl Mul<Ghash128> for Gf2

type Output = Ghash128

The resulting type after applying the * operator.

fn mul(self, rhs: Ghash128) -> Self::Output

Performs the * operation.

impl<T: Into<Self>> MulAssign<T> for Ghash128

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl Neg for Ghash128

type Output = Ghash128

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for Ghash128

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl Packable for Ghash128

impl PartialEq for Ghash128

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Ghash128

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PrimeCharacteristicRing for Ghash128

fn halve(&self) -> Self

Panics

Always panics: 2 is not invertible in characteristic 2.

fn div_2exp_u64(&self, _exp: u64) -> Self

Panics

Always panics: 2 is not invertible in characteristic 2.

fn bool_check(&self) -> Self

x·(x - 1) = x² - x = x² + x in characteristic 2, and poly_square_128 skips the cross-term carryless multiplies a general product pays for.

const ZERO: Self

The additive identity of the ring.

const ONE: Self

The multiplicative identity of the ring.

const TWO: Self

The element in the ring given by ONE + ONE.

const NEG_ONE: Self

The element in the ring given by -ONE.

type PrimeSubfield = Gf2

The field ℤ/p where the characteristic of this ring is p.

fn zero_vec(len: usize) -> Vec<Self>

Allocates a vector of zero elements of length len. Many operating systems zero pages before assigning them to a userspace process. In that case, our process should not need to write zeros, which would be redundant. However, the compiler may not always recognize this.

fn from_prime_subfield(f: Self::PrimeSubfield) -> Self

Embed an element of the prime field ℤ/p into the ring R.

fn from_bool(b: bool) -> Self

Return Self::ONE if b is true and Self::ZERO if b is false.

fn double(&self) -> Self

The elementary function double(a) = 2*a.

fn xor(&self, y: &Self) -> Self

Computes the arithmetic generalization of boolean xor.

fn mul_2exp_u64(&self, exp: u64) -> Self

The elementary function mul_2exp_u64(a, exp) = a * 2^{exp}.

fn square(&self) -> Self

The elementary function square(a) = a^2.

fn dot_product<const N: usize>(u: &[Self; N], v: &[Self; N]) -> Self

Compute the dot product of two vectors.

fn from_u8(int: u8) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_u16(int: u16) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_u32(int: u32) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_u64(int: u64) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_u128(int: u128) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_usize(int: usize) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_i8(int: i8) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_i16(int: i16) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_i32(int: i32) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_i64(int: i64) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_i128(int: i128) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_isize(int: isize) -> Self

Given an integer r, return the sum of r copies of ONE:

fn cube(&self) -> Self

The elementary function cube(a) = a^3.

fn xor3(&self, y: &Self, z: &Self) -> Self

Computes the arithmetic generalization of a triple xor.

fn andn(&self, y: &Self) -> Self

Computes the arithmetic generalization of andnot.

fn exp_u64(&self, power: u64) -> Self

Exponentiation by a u64 power.

fn exp_const_u64<const POWER: u64>(&self) -> Self

Exponentiation by a small constant power.

fn exp_power_of_2(&self, power_log: usize) -> Self

The elementary function exp_power_of_2(a, power_log) = a^{2^power_log}.

fn powers(&self) -> Powers<Self>

Construct an iterator which returns powers of self: self^0, self^1, self^2, ....

fn shifted_powers(&self, start: Self) -> Powers<Self>

Construct an iterator which returns powers of self shifted by start: start, start*self^1, start*self^2, ....

fn sum_array<const N: usize>(input: &[Self]) -> Self

Compute the sum of a slice of elements whose length is a compile time constant.

impl Product for Ghash128

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

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

impl RawDataSerializable for Ghash128

const NUM_BYTES: usize = 16

The number of bytes which this field element occupies in memory. Must be equal to the length of self.into_bytes().

fn into_bytes(self) -> impl IntoIterator<Item = u8>

Convert a field element into a collection of bytes.

fn into_byte_stream( input: impl IntoIterator<Item = Self>, ) -> impl IntoIterator<Item = u8>

Convert an iterator of field elements into an iterator of bytes.

fn into_u32_stream( input: impl IntoIterator<Item = Self>, ) -> impl IntoIterator<Item = u32>

Convert an iterator of field elements into an iterator of u32s.

fn into_u64_stream( input: impl IntoIterator<Item = Self>, ) -> impl IntoIterator<Item = u64>

Convert an iterator of field elements into an iterator of u64s.

fn into_parallel_byte_streams<const N: usize>( input: impl IntoIterator<Item = [Self; N]>, ) -> impl IntoIterator<Item = [u8; N]>

Convert an iterator of field element arrays into an iterator of byte arrays.

fn into_parallel_u32_streams<const N: usize>( input: impl IntoIterator<Item = [Self; N]>, ) -> impl IntoIterator<Item = [u32; N]>

Convert an iterator of field element arrays into an iterator of u32 arrays.

fn into_parallel_u64_streams<const N: usize>( input: impl IntoIterator<Item = [Self; N]>, ) -> impl IntoIterator<Item = [u64; N]>

Convert an iterator of field element arrays into an iterator of u64 arrays.

impl Serialize for Ghash128

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Ghash128

impl Sub for Ghash128

type Output = Ghash128

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl Sub<BinaryField8> for Ghash128

type Output = Ghash128

The resulting type after applying the - operator.

fn sub(self, rhs: BinaryField8) -> Self

Performs the - operation.

impl Sub<BinaryField16> for Ghash128

type Output = Ghash128

The resulting type after applying the - operator.

fn sub(self, rhs: BinaryField16) -> Self

Performs the - operation.

impl Sub<BinaryField32> for Ghash128

type Output = Ghash128

The resulting type after applying the - operator.

fn sub(self, rhs: BinaryField32) -> Self

Performs the - operation.

impl Sub<BinaryField64> for Ghash128

type Output = Ghash128

The resulting type after applying the - operator.

fn sub(self, rhs: BinaryField64) -> Self

Performs the - operation.

impl Sub<BinaryField128> for Ghash128

fn sub(self, rhs: BinaryField128) -> Self

The difference, in the polynomial basis.

The tower operand is converted first, which costs sixteen table lookups.

type Output = Ghash128

The resulting type after applying the - operator.

impl Sub<Gf2> for Ghash128

type Output = Ghash128

The resulting type after applying the - operator.

fn sub(self, rhs: Gf2) -> Self

Performs the - operation.

impl Sub<Ghash128> for BinaryField8

type Output = Ghash128

The resulting type after applying the - operator.

fn sub(self, rhs: Ghash128) -> Self::Output

Performs the - operation.

impl Sub<Ghash128> for BinaryField16

type Output = Ghash128

The resulting type after applying the - operator.

fn sub(self, rhs: Ghash128) -> Self::Output

Performs the - operation.

impl Sub<Ghash128> for BinaryField32

type Output = Ghash128

The resulting type after applying the - operator.

fn sub(self, rhs: Ghash128) -> Self::Output

Performs the - operation.

impl Sub<Ghash128> for BinaryField64

type Output = Ghash128

The resulting type after applying the - operator.

fn sub(self, rhs: Ghash128) -> Self::Output

Performs the - operation.

impl Sub<Ghash128> for Gf2

type Output = Ghash128

The resulting type after applying the - operator.

fn sub(self, rhs: Ghash128) -> Self::Output

Performs the - operation.

impl<T: Into<Self>> SubAssign<T> for Ghash128

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl Sum for Ghash128

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

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

impl TowerLevel for Ghash128

fn mul_alpha(self) -> Self

That generator is a basis element in the tower, which gets this for a shift. Here it is an arbitrary element, so it costs a full product.

fn from_le_byte_iter(bytes: impl Iterator<Item = u8>) -> Self

Panics

Panics if the stream ends before a whole element has been read.

fn cantor_basis(i: usize) -> Self

Panics

Panics if the index is at least the bit width of the field.

const LOG_BITS: usize = 7

The k in GF(2^(2^k)).

type Repr = u128

The backing integer of an element.

fn from_repr(r: Self::Repr) -> Self

Build an element from a bit pattern, discarding the bits above 2^LOG_BITS.

fn to_repr(self) -> Self::Repr

The bit pattern of this element, zero above 2^LOG_BITS.