Struct fuzzytags::RootSecret

pub struct RootSecret<const GAMMA: u8> { /* fields omitted */ }

The complete secret. Can’t directly be used for testing. Instead you will need to generate a DetectionKey using extract_detection_key

Implementations

impl<const GAMMA: u8> RootSecret<{ GAMMA }>

pub fn generate<R: RngCore + CryptoRng>(rng: &mut R) -> RootSecret<{ GAMMA }>

Generate a new Key Pair given a security parameter GAMMA. Tags generated for a given TaggingKey::generate_tag will pass the DetectionKey::test_tag for other tagging keys with probability $ 2 ^ -8 $ Example:

    use fuzzytags::{RootSecret};
    use rand::rngs::OsRng;
    let mut rng = OsRng;
    let secret = RootSecret::<24>::generate(&mut rng);

pub fn extract_detection_key(&self, n: usize) -> DetectionKey<{ GAMMA }>

extract a detection key for a given false positive (p = 2^-n) This is the key that can be given to adversarail servers so that they can detected messages that may be tagged for a given detection key with an ideal false positive rate 2^{-n} Example:

    use fuzzytags::{RootSecret};
    use rand::rngs::OsRng;
    let mut rng = OsRng;
    let secret = RootSecret::<24>::generate(&mut rng);
    let detection_key = secret.extract_detection_key(2);

pub fn tagging_key(&self) -> TaggingKey<{ GAMMA }>

derive the tagging key for this secret Example:

    use fuzzytags::RootSecret;
    use rand::rngs::OsRng;
    let mut rng = OsRng;
    let secret = RootSecret::<24>::generate(&mut rng);
    let tagging_key = secret.tagging_key();

Trait Implementations

impl<'de, const GAMMA: u8> Deserialize<'de> for RootSecret<GAMMA>

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

Deserialize this value from the given Serde deserializer.

impl<const GAMMA: u8> Serialize for RootSecret<GAMMA>

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

Serialize this value into the given Serde serializer.