Struct elgamal_ristretto::PublicKey

pub struct PublicKey(_);

The PublicKey struct represents an ElGamal public key.

Methods

impl PublicKey

pub fn encrypt(self, message: RistrettoPoint) -> Ciphertext

Encrypts a message in the Ristretto group. It has the additive homomorphic property, allowing addition (and subtraction) by another ciphertext and multiplication (and division) by scalars.

#Example

extern crate rand;
extern crate curve25519_dalek;
extern crate elgamal_ristretto;
use rand::rngs::OsRng;
use elgamal_ristretto::{PublicKey, SecretKey};
use curve25519_dalek::ristretto::{RistrettoPoint, };
use curve25519_dalek::scalar::{Scalar, };

       let mut csprng = OsRng::new().unwrap();
       // Generate key pair
       let sk = SecretKey::new(&mut csprng);
       let pk = PublicKey::from(&sk);

       // Generate random messages
       let ptxt1 = RistrettoPoint::random(&mut csprng);
       let ptxt2 = RistrettoPoint::random(&mut csprng);

       // Encrypt messages
       let ctxt1 = pk.encrypt(ptxt1);
       let ctxt2 = pk.encrypt(ptxt2);

       // Add ciphertexts and check that addition is maintained in the plaintexts
       let encrypted_addition = ctxt1 + ctxt2;
       let decrypted_addition = sk.decrypt(encrypted_addition);

       assert_eq!(ptxt1 + ptxt2, decrypted_addition);

       // Multiply by scalar and check that multiplication is maintained in the plaintext
       let scalar_mult = Scalar::random(&mut csprng);
       assert_eq!(sk.decrypt(ctxt1 * scalar_mult), scalar_mult * ptxt1);

pub fn encrypt_and_prove(
    self,
    message: RistrettoPoint
) -> (Ciphertext, CompactProof)

Encrypts a message in the Ristretto group and generates a proof of correct encryption

#Example

extern crate rand;
extern crate curve25519_dalek;
extern crate elgamal_ristretto;
use rand::rngs::OsRng;
use elgamal_ristretto::{PublicKey, SecretKey};
use curve25519_dalek::ristretto::{RistrettoPoint, };

let mut csprng = OsRng::new().unwrap();
       let sk = SecretKey::new(&mut csprng);
       let pk = PublicKey::from(&sk);

       let plaintext = RistrettoPoint::random(&mut csprng);
       // Encrypt plaintext and generate proof
       let (enc_plaintext, proof) = pk.encrypt_and_prove(plaintext);

       // Verify proof
       assert!(enc_plaintext.verify_correct_encryption(&plaintext, proof));

pub fn get_point(&self) -> RistrettoPoint

Get the public key as a RistrettoPoint

pub fn verify_signature(
    self,
    message: &RistrettoPoint,
    signature: (Scalar, RistrettoPoint)
) -> bool

Verify EdDSA signature

#Example

extern crate rand;
extern crate curve25519_dalek;
extern crate elgamal_ristretto;
use rand::rngs::OsRng;
use elgamal_ristretto::{PublicKey, SecretKey};
use curve25519_dalek::ristretto::RistrettoPoint;

      // Generate key-pair
      let mut csprng = OsRng::new().unwrap();
      let sk = SecretKey::new(&mut csprng);
      let pk = PublicKey::from(&sk);

      // Sign message
      let msg = RistrettoPoint::random(&mut csprng);
      let signature = sk.sign(msg);
      // Verify signature
      assert!(pk.verify_signature(&msg, signature));

      // Verify signature against incorrect message
      assert!(!pk.verify_signature(&RistrettoPoint::random(&mut csprng), signature))

pub fn verify_proof_knowledge(self, proof: CompactProof) -> bool

Verify proof of knowledege of private key related to a public key

Example

extern crate rand;
extern crate curve25519_dalek;
extern crate elgamal_ristretto;
use rand::rngs::OsRng;
use elgamal_ristretto::{PublicKey, SecretKey};
use curve25519_dalek::ristretto::RistrettoPoint;

      let mut csprng = OsRng::new().unwrap();
      let sk = SecretKey::new(&mut csprng);
      let pk = PublicKey::from(&sk);

      let proof = sk.prove_knowledge();
      assert!(pk.verify_proof_knowledge(proof));

pub fn verify_correct_decryption(
    self,
    proof: CompactProof,
    ciphertext: Ciphertext,
    plaintext: RistrettoPoint
) -> bool

Verify correct decryption

Example

extern crate rand;
extern crate curve25519_dalek;
extern crate elgamal_ristretto;
use rand::rngs::OsRng;
use elgamal_ristretto::{PublicKey, SecretKey};
use curve25519_dalek::ristretto::RistrettoPoint;

   let mut csprng = OsRng::new().unwrap();
   let sk = SecretKey::new(&mut csprng);
   let pk = PublicKey::from(&sk);

   let plaintext = RistrettoPoint::random(&mut csprng);
   let ciphertext = pk.encrypt(plaintext);

   let decryption = sk.decrypt(ciphertext);
   let proof = sk.prove_correct_decryption(ciphertext, decryption);

   assert!(pk.verify_correct_decryption(proof, ciphertext, decryption));

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

Convert to bytes

pub fn from_bytes(bytes: &[u8]) -> PublicKey

Generate public key from bytes

Trait Implementations

impl From<RistrettoPoint> for PublicKey

fn from(point: RistrettoPoint) -> PublicKey

Given a secret key, compute its corresponding Public key

impl<'a> From<&'a SecretKey> for PublicKey

fn from(secret: &'a SecretKey) -> PublicKey

Given a secret key, compute its corresponding Public key

impl Clone for PublicKey

fn clone(&self) -> PublicKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for PublicKey

impl PartialEq<PublicKey> for PublicKey

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl Debug for PublicKey

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

Formats the value using the given formatter.

impl Serialize for PublicKey

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

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for PublicKey

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.