Struct Tag 

pub struct Tag { /* private fields */ }

Tag

The Tag allows to store bytes alongside entities (keys, and ciphertexts) the main purpose of this system is to tag / identify ciphertext with their keys.

TFHE-rs generally does not interpret or check this data, it only stores it and passes it around.

The crate::upgrade::UpgradeKeyChain uses the tag to differentiate keys

The rules for how the Tag is passed around are:

• When encrypted, a ciphertext gets the tag of the key used to encrypt it.
• Ciphertexts resulting from operations (add, sub, etc.) get the tag from the ServerKey used
• PublicKey gets its tag from the ClientKey that was used to create it
• ServerKey gets its tag from the ClientKey that was used to create it

User can change the tag of any entities at any point.

Example

use rand::random;
use tfhe::prelude::*;
use tfhe::{ClientKey, ConfigBuilder, FheUint32, ServerKey};

// Generate the client key then set its tag
let mut cks = ClientKey::generate(ConfigBuilder::default());
let tag_value = random();
cks.tag_mut().set_u64(tag_value);
assert_eq!(cks.tag().as_u64(), tag_value);

// The server key inherits the client key tag
let sks = ServerKey::new(&cks);
assert_eq!(sks.tag(), cks.tag());

// Encrypted data inherits the tag of the encryption key
let a = FheUint32::encrypt(32832u32, &cks);
assert_eq!(a.tag(), cks.tag());

Implementations

impl Tag

pub fn data(&self) -> &[u8]

Returns a slice to the bytes stored

pub fn as_slice(&self) -> &[u8]

Returns a slice to the bytes stored (same a Self::data)

pub fn as_mut_slice(&mut self) -> &mut [u8]

Returns a mutable slice to the bytes stored

pub fn len(&self) -> usize

Returns the len, i.e. the number of bytes stored in the tag

pub fn is_empty(&self) -> bool

Returns whether the tag is empty

pub fn as_u64(&self) -> u64

Return the u64 value when interpreting the bytes as a u64

• Bytes are interpreted in little endian
• Bytes above the 8th are ignored

pub fn as_u128(&self) -> u128

Return the u128 value when interpreting the bytes as a u128

• Bytes are interpreted in little endian
• Bytes above the 16th are ignored

pub fn set_data(&mut self, data: &[u8])

Sets the data stored in the tag

This overwrites existing data stored

pub fn set_u64(&mut self, value: u64)

Sets the tag with the given u64 value

• Bytes are stored in little endian
• This overwrites existing data stored

pub fn set_u128(&mut self, value: u128)

Sets the tag with the given u128 value

• Bytes are stored in little endian
• This overwrites existing data stored

Trait Implementations

impl Clone for Tag

fn clone(&self) -> Tag

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tag

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

Formats the value using the given formatter.

impl Default for Tag

fn default() -> Tag

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Tag

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&str> for Tag

fn from(value: &str) -> Self

Converts to this type from the input type.

impl From<u64> for Tag

fn from(value: u64) -> Self

Converts to this type from the input type.

impl PartialEq for Tag

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Tag

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Unversionize for Tag

where TagVersions: VersionsDispatch<Self>,

fn unversionize( versioned: Self::VersionedOwned, ) -> Result<Self, UnversionizeError>

Creates an object from a versioned enum, and eventually upgrades from previous variants.

impl UnversionizeVec for Tag

where TagVersions: VersionsDispatch<Self>,

fn unversionize_vec( versioned: Self::VersionedVec, ) -> Result<Vec<Self>, UnversionizeError>

impl Version for Tag

where SmallVec: VersionizeOwned + Unversionize + Versionize,

type Ref<'vers> = TagVersion<'vers>

type Owned = TagVersionOwned

impl Versionize for Tag

where TagVersions: VersionsDispatch<Self>,

type Versioned<'vers> = <TagVersions as VersionsDispatch<Tag>>::Ref<'vers>

The equivalent versioned type. It should have a variant for each version. It may own the underlying data or only hold a read-only reference to it.

fn versionize(&self) -> Self::Versioned<'_>

Wraps the object into a versioned enum with a variant for each version. This will use references on the underlying types if possible.

impl VersionizeOwned for Tag

where TagVersions: VersionsDispatch<Self>,

type VersionedOwned = <TagVersions as VersionsDispatch<Tag>>::Owned

fn versionize_owned(self) -> Self::VersionedOwned

Wraps the object into a versioned enum with a variant for each version. This will clone the underlying types.

impl VersionizeSlice for Tag

where TagVersions: VersionsDispatch<Self>,

type VersionedSlice<'vers> = Vec<<Tag as Versionize>::Versioned<'vers>>

fn versionize_slice(slice: &[Self]) -> Self::VersionedSlice<'_>

impl VersionizeVec for Tag

where TagVersions: VersionsDispatch<Self>,

type VersionedVec = Vec<<Tag as VersionizeOwned>::VersionedOwned>

fn versionize_vec(vec: Vec<Self>) -> Self::VersionedVec

impl VersionsDispatch<Tag> for TagVersions

where Tag: Version,

type Ref<'vers> = TagVersionsDispatch<'vers>

type Owned = TagVersionsDispatchOwned

impl Eq for Tag

impl StructuralPartialEq for Tag