Struct Ciphertext

pub struct Ciphertext<G: Group> { /* private fields */ }

Ciphertext for ElGamal encryption.

A ciphertext consists of 2 group elements: the random element R and a blinded encrypted value B. If the ciphertext encrypts integer value v, it holds that

R = [r]G;
B = [v]G + [r]K = [v]G + [k]R;

where:

• G is the conventional group generator
• r is a random scalar selected by the encrypting party
• K and k are the recipient’s public and private keys, respectively.

Ciphertexts are partially homomorphic: they can be added together or multiplied by a scalar value.

Examples

Basic usage and arithmetic for ciphertexts:

// Generate a keypair for the ciphertext receiver.
let mut rng = thread_rng();
let receiver = Keypair::<Ristretto>::generate(&mut rng);
// Create a couple of ciphertexts.
let mut enc = receiver.public().encrypt(2_u64, &mut rng);
enc += receiver.public().encrypt(3_u64, &mut rng) * 4;
// Check that the ciphertext decrypts to 2 + 3 * 4 = 14.
let lookup_table = DiscreteLogTable::new(0..20);
let decrypted = receiver.secret().decrypt(enc, &lookup_table);
assert_eq!(decrypted, Some(14));

Creating a ciphertext of a boolean value together with a proof:

// Generate a keypair for the ciphertext receiver.
let mut rng = thread_rng();
let receiver = Keypair::<Ristretto>::generate(&mut rng);
// Create and verify a boolean encryption.
let (enc, proof) =
    receiver.public().encrypt_bool(false, &mut rng);
receiver.public().verify_bool(enc, &proof)?;

Creating a ciphertext of an integer value together with a range proof:

// Generate the ciphertext receiver.
let mut rng = thread_rng();
let receiver = Keypair::<Ristretto>::generate(&mut rng);
// Find the optimal range decomposition for our range
// and specialize it for the Ristretto group.
let range = RangeDecomposition::optimal(100).into();

let (ciphertext, proof) = receiver
    .public()
    .encrypt_range(&range, 42, &mut rng);

// Check that the the proof verifies.
receiver.public().verify_range(&range, ciphertext, &proof)?;

Implementations

impl<G: Group> Ciphertext<G>

pub fn zero() -> Self

Represents encryption of zero value without the blinding factor.

pub fn non_blinded<T>(value: T) -> Self

where G::Scalar: From<T>,

Creates a non-blinded encryption of the specified scalar value, i.e., (O, [value]G) where O is identity and G is the conventional group generator.

pub fn random_element(&self) -> &G::Element

Returns a reference to the random element.

pub fn blinded_element(&self) -> &G::Element

Returns a reference to the blinded element.

pub fn to_bytes(self) -> Vec<u8>

Serializes this ciphertext as two group elements (the random element, then the blinded value).

Trait Implementations

impl<G: Group> Add for Ciphertext<G>

type Output = Ciphertext<G>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<G: Group> AddAssign for Ciphertext<G>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<G: Clone + Group> Clone for Ciphertext<G>

where G::Element: Clone,

fn clone(&self) -> Ciphertext<G>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Group> Debug for Ciphertext<G>

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

Formats the value using the given formatter.

impl<'de, G: Group> Deserialize<'de> for Ciphertext<G>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<G: Group, V: Zeroize> From<CiphertextWithValue<G, V>> for Ciphertext<G>

fn from(ciphertext: CiphertextWithValue<G, V>) -> Self

Converts to this type from the input type.

impl<G: Group> Mul<&<G as ScalarOps>::Scalar> for Ciphertext<G>

type Output = Ciphertext<G>

The resulting type after applying the * operator.

fn mul(self, rhs: &G::Scalar) -> Self

Performs the * operation.

impl<G: Group> Mul<u64> for Ciphertext<G>

type Output = Ciphertext<G>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<G: Group> Neg for Ciphertext<G>

type Output = Ciphertext<G>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<G: Group> Serialize for Ciphertext<G>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<G: Group> Sub for Ciphertext<G>

type Output = Ciphertext<G>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<G: Group> SubAssign for Ciphertext<G>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<G: Copy + Group> Copy for Ciphertext<G>

where G::Element: Copy,