Struct Triple 

pub struct Triple {
    ek: RistrettoPoint,
    ct: RistrettoPoint,
    pk: RistrettoPoint,
}

ElGamal ciphertext - the result of PublicKey::encrypt.

The associated public key is remembered to allow rerandomization, but this public key is not authenticated in any way. This means that anyone intercepting a triple may modify the public key without detection (but this does not cause the triple to be decryptable to the same plaintext by another public key.)

Fields

ek: RistrettoPoint

Ephemeral key

ct: RistrettoPoint

Ciphertext,

pk: RistrettoPoint

Public key

Implementations

impl Triple

pub fn decrypt(self, sk: &PrivateKey) -> RistrettoPoint

Decrypts the triple using the given private key sk. If the triple was encrypted for a different private key, the result is a random point.

pub fn decrypt_and_check_pk(self, sk: &PrivateKey) -> Option<RistrettoPoint>

Decrypts the triple using the given private key sk if the triple claims to be encrypted for the associated public key; returns None otherwise.

Warning This function can’t check whether the triple’s public key pk has been tampered with.

While tampering cannot be prevented, the plaintext of a triple with spoofed pk can be garbled, using Self::rerandomize.

pub fn spoof_pk(self, pk: PublicKey) -> Triple

Changes the public key of this triple, likely resulting in garbage down the road.

Used for demonstration purposes.

pub fn rerandomize(self) -> Triple

Changes the appearance of the ciphertext, but leaves the plaintext and the target public key unaltered. If the public key was spoofed, the plaintext is garbled.

use pubhubs::common::elgamal::{PrivateKey, random_point, random_scalar};
use curve25519_dalek::{
    ristretto::RistrettoPoint,
    constants::RISTRETTO_BASEPOINT_TABLE as B,
};

let M = random_point();
let sk = PrivateKey::random();
let pk = sk.public_key();

let r1 = random_scalar();
let r2 = random_scalar();

// Rerandomization leaves the plaintext unchanged:
let trip = pk.encrypt_with_random(r1, M).rerandomize_with_random(r2);
assert_eq!(trip, pk.encrypt_with_random(r1+r2,M));

// But if the public key was spoofed, the plaintext is garbled:
let sk2 = PrivateKey::random();
let pk2 = sk2.public_key().clone();
let trip = pk.encrypt_with_random(r1, M).spoof_pk(pk2).rerandomize_with_random(r2);

assert_eq!(trip.clone().decrypt_and_check_pk(&sk2),
    Some(M + B * &(r1 * (sk.as_scalar()-sk2.as_scalar()))));

// Indeed, if sk =/= sk2, then  r1(sk - sk2)B will be some random unknowable Ristretto
// point, because r1 should be a random scalar that has been thrown away.

pub fn rerandomize_with_random(self, r: Scalar) -> Triple

Like Self::rerandomize, but you can specify the random scalar used - which you shouldn’t except to make deterministic tests.

pub fn rsk_with_s(self, s: &Scalar) -> WithS<'_>

Like rsk but taking the parameters s and k thusly: rsk_with_s(s).and_k(k).

pub fn rsk(self, params: impl Params) -> Triple

Changes the given ciphertext according to the params provided:

• Multiplies the underlying plaintext by params.s();

• Multiplies the target public/private key by params.k();

• Rerandomizes the ciphertext using the scalar params.r().

  If the public key self.pk was spoofed, the resulting plaintext is garbled, provided the scalar params.r() was random.

If you only need to specify s and k, use triple.rsk_with_s(s).and_k(k) instead.

Trait Implementations

impl Clone for Triple

fn clone(&self) -> Triple

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Triple

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Triple

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Encoding<96> for Triple

fn from_bytes(bytes: [u8; 96]) -> Option<Triple>

Decodes Some(object) from bytes if bytes encodes some object of type Self; otherwise returns None.

fn to_bytes(&self) -> [u8; 96]

Encodes self as [u8; N].

fn from_slice(slice: &[u8]) -> Option<Self>

Like Self::from_bytes, but reads [u8; N] from slice. Returns None if slice.len()!=N or when the slice is not a valid encoding.

fn copy_to_slice(&self, slice: &mut [u8]) -> Option<()>

Copies the encoding of self into slice. Returns None when slice.len()!=N.

fn from_hex(hex: &str) -> Option<Self>

Like Self::from_bytes, but reads the [u8; N] from the 2*N-digit hex string hex. The case of the hex digits is ignored.

fn to_hex(&self) -> String

Returns the 2*N-digit lower-case hex representation of self.

unsafe fn from_ptr(ptr: *const u8) -> Option<Self>

Loads object from the N-byte buffer pointed to by ptr.

unsafe fn copy_to_ptr(self, ptr: *mut u8)

Writes the N-byte representation of this object to the memory location ptr.

impl PartialEq for Triple

fn eq(&self, other: &Triple) -> 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<'de> Serialize for Triple

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for Triple

impl StructuralPartialEq for Triple