Struct Transcript 

pub struct Transcript { /* private fields */ }

Provides a convenient abstraction over hashing data and deriving randomness.

It automatically takes care of details like:

• correctly segmenting packets of data,
• domain separating different uses of tags and randomness,
• making sure that secret state is zeroized as necessary.

Implementations

impl Transcript

pub fn new(namespace: &[u8]) -> Self

Create a new transcript.

The namespace serves to disambiguate two transcripts, so that even if they record the same information, the results will be different:

let s1 = Transcript::new(b"n1").commit(b"A".as_slice()).summarize();
let s2 = Transcript::new(b"n2").commit(b"A".as_slice()).summarize();
assert_ne!(s1, s2);

pub fn resume(summary: Summary) -> Self

Start a transcript from a summary.

Note that this will not produce the same result as if the transcript were never summarized to begin with.

let s1 = Transcript::new(b"test").commit(b"A".as_slice()).summarize();
let s2 = Transcript::resume(s1.clone()).summarize();
assert_ne!(s1, s2);

pub fn commit(&mut self, data: impl Buf) -> &mut Self

Record data in this transcript.

Calls to record automatically separate out data:

let s1 = Transcript::new(b"test").commit(b"A".as_slice()).commit(b"B".as_slice()).summarize();
let s2 = Transcript::new(b"test").commit(b"AB".as_slice()).summarize();
assert_ne!(s1, s2);

In particular, even a call with an empty string matters:

let s1 = Transcript::new(b"test").summarize();
let s2 = Transcript::new(b"testt").commit(b"".as_slice()).summarize();
assert_ne!(s1, s2);

If you want to provide data incrementally, use Self::append.

pub fn append(&mut self, data: impl Buf) -> &mut Self

Like Self::commit, except that subsequent calls to Self::append or Self::commit are considered part of the same message.

Self::commit needs to be called before calling any other method, besides Self::append, in order to avoid having uncommitted data.

let s1 = Transcript::new(b"test").append(b"A".as_slice()).commit(b"B".as_slice()).summarize();
let s2 = Transcript::new(b"test").commit(b"AB".as_slice()).summarize();
assert_eq!(s1, s2);

pub fn fork(&self, label: &'static [u8]) -> Self

Create a new instance sharing the same history.

This instance will commit to the same data, but it will produce a different summary and noise:

let t = Transcript::new(b"test");
assert_ne!(t.summarize(), t.fork(b"A").summarize());
assert_ne!(t.fork(b"A").summarize(), t.fork(b"B").summarize());

pub fn noise(&self, label: &'static [u8]) -> impl CryptoRngCore

Pull out some noise from this transript.

This noise will depend on all of the messages committed to the transcript so far, and can be used as a secure source of randomness, for generating keys, and other things.

The label will also affect the noise. Changing the label will change the stream of bytes generated.

pub fn summarize(&self) -> Summary

Extract a compact summary from this transcript.

This can be used to compare transcripts for equality:

let s1 = Transcript::new(b"test").commit(b"DATA".as_slice()).summarize();
let s2 = Transcript::new(b"test").commit(b"DATA".as_slice()).summarize();
assert_eq!(s1, s2);

Trait Implementations

impl Drop for Transcript

fn drop(&mut self)

Executes the destructor for this type.