Struct PHashSalt 

pub struct PHashSalt(/* private fields */);

Perceptual hash of the container image, used as the Argon2id salt.

The bytes are wiped when the value is dropped. Like MasterKey, the type implements neither Clone, Copy nor Debug: the salt is not a secret in the sense a key is, but it is a deterministic function of the container, and leaking it into a log would let an attacker confirm which image a given payload belongs to.

Why it compares and hashes, but still does not print

Two images that produce one salt produce one key and one nonce under any given password, so a caller holding several containers has a question worth asking about them: do any two of these collide? PartialEq, Eq and Hash are derived to answer exactly that, and to answer it in linear time — grouping by salt needs a hash-map key, and comparing every pair instead would be quadratic in the size of a photo library.

Equality is the whole of what a caller gets. as_bytes stays crate-private and there is no public path to the 64 hash bits, so an outside program can learn that two of its own files collide and cannot learn the value that made them collide, nor compute a fingerprint it could compare against an image it does not hold.

The comparison is not constant time and does not need to be. Both operands are derived in-process from files the caller already has in front of them; there is no remote party feeding one side of it, and nothing timeable that the caller could not obtain by looking at the images.

Trait Implementations

impl Drop for PHashSalt

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for PHashSalt

impl Hash for PHashSalt

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PHashSalt

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for PHashSalt