Struct clacc::Accumulator

pub struct Accumulator<T: BigInt, M: Map> { /* private fields */ }

An accumulator.

Elements may be added and deleted from the acculumator without increasing the size of its internal parameters. That is, the number of digits in the accumulation z will never exceed the number of digits in the modulus n.

Implementations

impl<T: BigInt, M: Map> Accumulator<T, M>

pub fn with_private_key(p: T, q: T) -> Self

Initialize an accumulator from private key parameters. All accumulators are able to add elements and verify witnesses. An accumulator constructed from a private key is able to delete elements and prove elements after their addition.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let p = vec![0x3d];
let q = vec![0x35];
let acc = Accumulator::<BigInt, Map>::with_private_key(
    <BigInt as clacc::BigInt>::from_bytes_be(p.as_slice()),
    <BigInt as clacc::BigInt>::from_bytes_be(q.as_slice()),
);

pub fn with_random_key<F: FnMut(&mut [u8])>( fill_bytes: F, key_bits: Option<usize> ) -> (Self, T, T)

Create an accumulator from a randomly generated private key and return it along with the generated key parameters.

If key_bits is None, the bit size of the generated modulus is 3072.

use clacc::{
    Accumulator,
    blake2::Map,
    BigInt as BigIntTrait,
};
use num_bigint::BigInt;
use rand::RngCore;
let mut rng = rand::thread_rng();
let acc = Accumulator::<BigInt, Map>::with_random_key(
    |bytes| rng.fill_bytes(bytes),
    Some(256),
).0;
assert_eq!(acc.get_public_key().size_in_bits(), 256);

pub fn with_public_key(n: T) -> Self

Initialize an accumulator from a public key. An accumulator constructed from a public key is only able to add elements and verify witnesses.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let n = vec![0x0c, 0xa1];
let acc = Accumulator::<BigInt, Map>::with_public_key(
   <BigInt as clacc::BigInt>::from_bytes_be( n.as_slice()),
);

pub fn get_public_key(&self) -> T

Get an accumulator’s public key.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let p = vec![0x3d];
let q = vec![0x35];
let n = vec![0x0c, 0xa1];
let mut acc = Accumulator::<BigInt, Map>::with_private_key(
    <BigInt as clacc::BigInt>::from_bytes_be(p.as_slice()),
    <BigInt as clacc::BigInt>::from_bytes_be(q.as_slice()),
);
assert_eq!(
  acc.get_public_key(),
  <BigInt as clacc::BigInt>::from_bytes_be(n.as_slice()),
);

pub fn add<'a, V: 'a + Clone + Into<Vec<u8>>>(&mut self, v: &'a V) -> Witness<T>

Add an element to an accumulator.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let n = vec![0x0c, 0xa1];
let mut acc = Accumulator::<BigInt, Map>::with_public_key(
    <BigInt as clacc::BigInt>::from_bytes_be(n.as_slice()),
);
let x = b"abc".to_vec();
let w = acc.add(&x);
assert!(acc.verify(&x, &w).is_ok());

This works with accumulators constructed from a public key or a private key.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let p = vec![0x3d];
let q = vec![0x35];
let mut acc = Accumulator::<BigInt, Map>::with_private_key(
    <BigInt as clacc::BigInt>::from_bytes_be(p.as_slice()),
    <BigInt as clacc::BigInt>::from_bytes_be(q.as_slice()),
);
let x = b"abc".to_vec();
let w = acc.add(&x);
assert!(acc.verify(&x, &w).is_ok());

pub fn del<'a, V: 'a + Clone + Into<Vec<u8>>>( &mut self, v: &'a V, w: &Witness<T> ) -> Result<T, Error>

Delete an element from an accumulator.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let p = vec![0x3d];
let q = vec![0x35];
let mut acc = Accumulator::<BigInt, Map>::with_private_key(
    <BigInt as clacc::BigInt>::from_bytes_be(p.as_slice()),
    <BigInt as clacc::BigInt>::from_bytes_be(q.as_slice()),
);
let x = b"abc".to_vec();
let w = acc.add(&x);
assert!(acc.del(&x, &w).is_ok());
assert!(acc.verify(&x, &w).is_err());
assert!(acc.del(&x, &w).is_err());

This will only succeed with an accumulator constructed from a private key.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let n = vec![0x0c, 0xa1];
let mut acc = Accumulator::<BigInt, Map>::with_public_key(
    <BigInt as clacc::BigInt>::from_bytes_be(n.as_slice())
);
let x = b"abc".to_vec();
let w = acc.add(&x);
assert!(acc.del(&x, &w).is_err());

pub fn prove<'a, V: 'a + Clone + Into<Vec<u8>>>( &self, v: &'a V ) -> Result<Witness<T>, Error>

Generate a witness to an element’s addition to the accumulation.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let p = vec![0x3d];
let q = vec![0x35];
let mut acc = Accumulator::<BigInt, Map>::with_private_key(
    <BigInt as clacc::BigInt>::from_bytes_be(p.as_slice()),
    <BigInt as clacc::BigInt>::from_bytes_be(q.as_slice()),
);
let x = b"abc".to_vec();
acc.add(&x);
let w = acc.prove(&x).unwrap();
assert!(acc.verify(&x, &w).is_ok());

This will only succeed with an accumulator constructed from a private key.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let n = vec![0x0c, 0xa1];
let mut acc = Accumulator::<BigInt, Map>::with_public_key(
    <BigInt as clacc::BigInt>::from_bytes_be(n.as_slice()),
);
let x = b"abc".to_vec();
acc.add(&x);
assert!(acc.prove(&x).is_err());

pub fn verify<'a, V: 'a + Clone + Into<Vec<u8>>>( &self, v: &'a V, w: &Witness<T> ) -> Result<(), Error>

Verify an element is a member of an accumulator.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let n = vec![0x0c, 0xa1];
let mut acc = Accumulator::<BigInt, Map>::with_public_key(
    <BigInt as clacc::BigInt>::from_bytes_be(n.as_slice()),
);
let x = b"abc".to_vec();
let w = acc.add(&x);
assert!(acc.verify(&x, &w).is_ok());

This works with accumulators constructed from a public key or a private key.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let p = vec![0x3d];
let q = vec![0x35];
let mut acc = Accumulator::<BigInt, Map>::with_private_key(
    <BigInt as clacc::BigInt>::from_bytes_be(p.as_slice()),
    <BigInt as clacc::BigInt>::from_bytes_be(q.as_slice()),
);
let x = b"abc".to_vec();
let w = acc.add(&x);
assert!(acc.verify(&x, &w).is_ok());

pub fn get_value(&self) -> T

Return the accumulation value as a BigInt.

use clacc::{
    Accumulator,
    Witness,
    blake2::Map,
};
use num_bigint::BigInt;
let n = vec![0x0c, 0xa1];
let mut acc = Accumulator::<BigInt, Map>::with_public_key(
    <BigInt as clacc::BigInt>::from_bytes_be(n.as_slice()),
);
let x = b"abc".to_vec();
let y = b"def".to_vec();
// Add an element.
acc.add(&x);
// Save the current accumulation. This value is effectively
// a witness for the next element added.
let u = acc.get_value().clone();
// Add another element.
let nonce = acc.add(&y).nonce;
let w = Witness {
    u: u,
    nonce: nonce,
};
// Verify that `w` is a witness for `y`.
assert!(acc.verify(&y, &w).is_ok());

pub fn set_value(&mut self, z: T)

Set the accumulation value from a BigInt.

use clacc::{
    Accumulator,
    blake2::Map,
};
use num_bigint::BigInt;
let p = vec![0x3d];
let q = vec![0x35];
let mut acc_prv = Accumulator::<BigInt, Map>::with_private_key(
    <BigInt as clacc::BigInt>::from_bytes_be(p.as_slice()),
    <BigInt as clacc::BigInt>::from_bytes_be(q.as_slice()),
);
let n = vec![0x0c, 0xa1];
let mut acc_pub = Accumulator::<BigInt, Map>::with_public_key(
    <BigInt as clacc::BigInt>::from_bytes_be(n.as_slice()),
);
let x = b"abc".to_vec();
let w = acc_prv.add(&x);
acc_pub.set_value(acc_prv.get_value());
assert!(acc_prv.verify(&x, &w).is_ok());

Trait Implementations

impl<T: Clone + BigInt, M: Clone + Map> Clone for Accumulator<T, M>

fn clone(&self) -> Accumulator<T, M>

Returns a copy of the value.

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

Performs copy-assignment from source.