Struct opaque_ke::key_exchange::group::ristretto255::Ristretto255

pub struct Ristretto255;

Implementation for Ristretto255.

Trait Implementations

impl CipherSuite for Ristretto255

const ID: u16 = 1u16

The ciphersuite identifier as dictated by https://datatracker.ietf.org/doc/draft-irtf-cfrg-voprf/

type Group = <Ristretto255 as CipherSuite>::Group

A finite cyclic group along with a point representation that allows some customization on how to hash an input to a curve point. See Group.

type Hash = <Ristretto255 as CipherSuite>::Hash

The main hash function to use (for HKDF computations and hashing transcripts).

impl Group for Ristretto255

type Elem = <Ristretto255 as Group>::Elem

The type of group elements

type ElemLen = <Ristretto255 as Group>::ElemLen

The byte length necessary to represent group elements

type Scalar = <Ristretto255 as Group>::Scalar

The type of base field scalars

type ScalarLen = <Ristretto255 as Group>::ScalarLen

The byte length necessary to represent scalars

fn hash_to_curve<H>(
    input: &[&[u8]],
    dst: &[u8]
) -> Result<Self::Elem, InternalError>where
    H: Digest + BlockSizeUser,
    H::OutputSize: IsLess<U256> + IsLessOrEqual<H::BlockSize>,

Transforms a password and domain separation tag (DST) into a curve point

fn hash_to_scalar<H>(
    input: &[&[u8]],
    dst: &[u8]
) -> Result<Self::Scalar, InternalError>where
    H: Digest + BlockSizeUser,
    H::OutputSize: IsLess<U256> + IsLessOrEqual<H::BlockSize>,

Hashes a slice of pseudo-random bytes to a scalar

fn base_elem() -> Self::Elem

Get the base point for the group

fn identity_elem() -> Self::Elem

Returns the identity group element

fn serialize_elem(elem: Self::Elem) -> GenericArray<u8, Self::ElemLen>

Serializes the self group element

fn deserialize_elem(element_bits: &[u8]) -> Result<Self::Elem>

Return an element from its fixed-length bytes representation. If the element is the identity element, return an error.

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

picks a scalar at random

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

The multiplicative inverse of this scalar

fn is_zero_scalar(scalar: Self::Scalar) -> Choice

Returns true if the scalar is zero.

fn serialize_scalar(scalar: Self::Scalar) -> GenericArray<u8, Self::ScalarLen>

Serializes a scalar to bytes

fn deserialize_scalar(scalar_bits: &[u8]) -> Result<Self::Scalar>

Return a scalar from its fixed-length bytes representation. If the scalar is zero or invalid, then return an error.

fn is_identity_elem(elem: Self::Elem) -> Choice

Returns true if the element is equal to the identity element

impl KeGroup for Ristretto255

type Pk = RistrettoPoint

Public key

type PkLen = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>

Length of the public key

type Sk = Scalar

Secret key

type SkLen = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>

Length of the secret key

fn serialize_pk(pk: Self::Pk) -> GenericArray<u8, Self::PkLen>

Serializes self

fn deserialize_pk(bytes: &[u8]) -> Result<Self::Pk, InternalError>

Return a public key from its fixed-length bytes representation

fn random_sk<R: RngCore + CryptoRng>(rng: &mut R) -> Self::Sk

Generate a random secret key

fn hash_to_scalar<'a, H>(
    input: &[&[u8]],
    dst: &[u8]
) -> Result<Self::Sk, InternalError>where
    H: Digest + BlockSizeUser,
    H::OutputSize: IsLess<U256> + IsLessOrEqual<H::BlockSize>,

Hashes a slice of pseudo-random bytes to a scalar

fn is_zero_scalar(scalar: Self::Sk) -> Choice

Returns true if the scalar is zero.

fn public_key(sk: Self::Sk) -> Self::Pk

Return a public key from its secret key

fn diffie_hellman(pk: Self::Pk, sk: Self::Sk) -> GenericArray<u8, Self::PkLen>

Diffie-Hellman key exchange

fn serialize_sk(sk: Self::Sk) -> GenericArray<u8, Self::SkLen>

Serializes self

fn deserialize_sk(bytes: &[u8]) -> Result<Self::Sk, InternalError>

Return a public key from its fixed-length bytes representation

fn derive_auth_keypair<CS: CipherSuite>(
    seed: &[u8],
    info: &[u8]
) -> Result<Self::Sk, InternalError>where
    <CS::Hash as OutputSizeUser>::OutputSize: IsLess<U256> + IsLessOrEqual<<CS::Hash as BlockSizeUser>::BlockSize>,

Corresponds to the DeriveAuthKeyPair() function defined in https://www.ietf.org/archive/id/draft-irtf-cfrg-opaque-08.html#section-6.4.2