Struct EphemeralSecret 

pub struct EphemeralSecret<C>
where
    C: CurveArithmetic,
{
    scalar: NonZeroScalar<C>,
}

Ephemeral Diffie-Hellman Secret.

These are ephemeral “secret key” values which are deliberately designed to avoid persistence.

To perform an ephemeral Diffie-Hellman exchange, do the following:

• Have each participant generate an EphemeralSecret value using the Generate trait
• Compute the PublicKey for that value
• Have each peer provide their PublicKey to their counterpart
• Use EphemeralSecret and the other participant’s PublicKey to compute a SharedSecret value using the EphemeralSecret::diffie_hellman function

⚠️ SECURITY WARNING ⚠️

Ephemeral Diffie-Hellman exchanges are unauthenticated and without a further authentication step are trivially vulnerable to man-in-the-middle attacks!

These exchanges should be performed in the context of a protocol which takes further steps to authenticate the peers in a key exchange.

Fields

scalar: NonZeroScalar<C>

Implementations

impl<C> EphemeralSecret<C>

where C: CurveArithmetic,

pub fn public_key(&self) -> PublicKey<C>

Get the public key associated with this ephemeral secret.

The compress flag enables point compression.

pub fn diffie_hellman(&self, public_key: &PublicKey<C>) -> SharedSecret<C>

Compute a Diffie-Hellman shared secret from an ephemeral secret and the public key of the other participant in the exchange.

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

👎Deprecated since 0.14.0: use the Generate trait instead

DEPRECATED: Generate a cryptographically random EphemeralSecret.

Use the Generate trait instead.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<C> Drop for EphemeralSecret<C>

where C: CurveArithmetic,

fn drop(&mut self)

Executes the destructor for this type.

impl<C> From<&EphemeralSecret<C>> for PublicKey<C>

where C: CurveArithmetic,

fn from(ephemeral_secret: &EphemeralSecret<C>) -> Self

Converts to this type from the input type.

impl<C> Generate for EphemeralSecret<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> Zeroize for EphemeralSecret<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> ZeroizeOnDrop for EphemeralSecret<C>

where C: CurveArithmetic,