Struct glycos::graph::cryptograph::VertexBuilder

pub struct VertexBuilder {
    derived_public: PublicKey,
    owner_recogniser: Recogniser,
    derivation_builder: EphemeralKeyDerivationBuilder,
    value: Option<Vec<u8>>,
    owner_cek: Option<Vec<u8>>,
    acl: VertexControlList,
    cek: [u8; 32],
    kek_ephemeral: PrivateKey,
    clock: u32,
}

A builder for Vertex’.

Building a Vertex takes several distinct steps:

1. Generate an owner key (taken care of by VertexBuilder::new());
2. Optionally permit access to others;
3. Assign an optional value;
4. Sign the vertex (using VertexBuilder::build()).

The signing operation will return the associated owner key.

Examples

use glycos::crypto::ec::*;
use glycos::graph::cryptograph::*;

let rng = ring::rand::SystemRandom::new();
let alice = PrivateKey::generate(&rng).expect("Generate key");
let public = alice.compute_public_key().unwrap();
let (v, k): (Vertex, PrivateKey) = VertexBuilder::new(&rng, &public).unwrap()
    .build(&rng, &alice).unwrap();

assert_eq!(v.check_acl(&alice).unwrap().unwrap(), k,
           "`build` should return the owner key.");

Fields

derived_public: PublicKey

owner_recogniser: Recogniser

derivation_builder: EphemeralKeyDerivationBuilder

value: Option<Vec<u8>>

owner_cek: Option<Vec<u8>>

acl: VertexControlList

cek: [u8; 32]

kek_ephemeral: PrivateKey

clock: u32

Implementations

impl VertexBuilder

pub fn new<R: SecureRandom>(rng: &R, master_key: &PublicKey) -> Result<Self>

Start the VertexBuilder process.

The master_key is the public key of the owner of the generated vertex. The corresponding private key should be provided at the end of the VertexBuilder, in VertexBuilder::build().

pub fn update_vertex<R: SecureRandom>(
    rng: &R,
    v: &Vertex,
    sk: &PrivateKey
) -> Result<Self>

Builds a VertexBuild from an existing vertex.

This destroys the current ACL, since this cannot be recovered! Use VertexBuilder::permit() to reinstantiate.

This operation also destroys all edges, rebuild them using EdgeBuilder!

pub fn value<Val: AsRef<[u8]>>(self, v: Val) -> Result<Self>

Set the optional value of the Vertex to a binary string.

Examples

use glycos::crypto::ec::*;
use glycos::graph::cryptograph::*;

let rng = ring::rand::SystemRandom::new();
let alice = PrivateKey::generate(&rng).expect("Generate key");
let public = alice.compute_public_key().unwrap();
let (v, k): (Vertex, PrivateKey) = VertexBuilder::new(&rng, &public).unwrap()
    .value(b"foaf:Person").unwrap()
    .build(&rng, &alice).unwrap();

pub fn permit(self, bob: &PublicKey) -> Result<Self>

Permit Bob to append data to this vertex

pub fn permit_many<Acl, Key>(self, keys: Acl) -> Result<Self> where
    Key: Borrow<PublicKey>,
    Acl: AsRef<[Key]>, 

Permit many to append data to this vertex

fn encrypt_cek(&self, bob: &PublicKey) -> Result<Vec<u8>>

pub fn build<R: SecureRandom>(
    self,
    rng: &R,
    sk: &PrivateKey
) -> Result<(Vertex, PrivateKey)>

Finish the Vertex.

The passed private key should be the corresponding PrivateKey to the PublicKey passed in VertexBuilder::new().