hash.rs 100.0%

83 of 83 lines run, 28 of 29 functions · run #275 on carry-identical · run missed

//! Object references: BLAKE3-256 over a domain-separating header and the body
//! (spec §5.2).

use std::fmt;

#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct ObjectRef(pub [u8; 32]);

/// A change is referenced by the ObjectRef of its encoding.
pub type ChangeHash = ObjectRef;
/// An identity is referenced by the ObjectRef of its encoding.
pub type KeyId = ObjectRef;

impl ObjectRef {
    /// Reserved: means "this change" inside a change (spec §5.2, §7.4).
    pub const ZERO: ObjectRef = ObjectRef([0; 32]);

    pub fn is_zero(&self) -> bool {
        *self == Self::ZERO
    }
    pub fn to_hex(&self) -> String {
        hex::encode(self.0)
    }
    pub fn from_hex(s: &str) -> Option<ObjectRef> {
        let v = hex::decode(s).ok()?;
        let a: [u8; 32] = v.try_into().ok()?;
        Some(ObjectRef(a))
    }
    pub fn from_slice(b: &[u8]) -> Option<ObjectRef> {
        let a: [u8; 32] = b.try_into().ok()?;
        Some(ObjectRef(a))
    }
    /// First `n` hex characters.
    pub fn short(&self, n: usize) -> String {
        let h = self.to_hex();
        h[..n.min(h.len())].to_string()
    }
    pub fn starts_with_hex(&self, prefix: &str) -> bool {
        self.to_hex().starts_with(prefix)
    }
}

impl fmt::Display for ObjectRef {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(&self.to_hex())
    }
}

impl fmt::Debug for ObjectRef {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "#{}", self.short(12))
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ObjectType {
    Chunk,
    Blob,
    Change,
    Checkpoint,
    Op,
    Attest,
    Identity,
    Policy,
    State,
    Receipt,
}

impl ObjectType {
    pub const ALL: [ObjectType; 10] = [
        ObjectType::Chunk,
        ObjectType::Blob,
        ObjectType::Change,
        ObjectType::Checkpoint,
        ObjectType::Op,
        ObjectType::Attest,
        ObjectType::Identity,
        ObjectType::Policy,
        ObjectType::State,
        ObjectType::Receipt,
    ];

    pub fn name(self) -> &'static str {
        match self {
            ObjectType::Chunk => "chunk",
            ObjectType::Blob => "blob",
            ObjectType::Change => "change",
            ObjectType::Checkpoint => "checkpoint",
            ObjectType::Op => "op",
            ObjectType::Attest => "attest",
            ObjectType::Identity => "identity",
            ObjectType::Policy => "policy",
            ObjectType::State => "state",
            ObjectType::Receipt => "receipt",
        }
    }

    pub fn from_name(s: &str) -> Option<ObjectType> {
        Self::ALL.iter().copied().find(|t| t.name() == s)
    }
}

/// `ObjectRef = BLAKE3-256("oxy1 " || type || " " || decimal(len) || 0x00 || body)`.
pub fn hash_object(ty: ObjectType, body: &[u8]) -> ObjectRef {
    let mut h = blake3::Hasher::new();
    h.update(&header(ty, body.len()));
    h.update(body);
    ObjectRef(*h.finalize().as_bytes())
}

pub fn header(ty: ObjectType, len: usize) -> Vec<u8> {
    let mut v = Vec::with_capacity(32);
    v.extend_from_slice(b"oxy1 ");
    v.extend_from_slice(ty.name().as_bytes());
    v.push(b' ');
    v.extend_from_slice(len.to_string().as_bytes());
    v.push(0);
    v
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn header_matches_spec() {
        assert_eq!(header(ObjectType::Chunk, 5), b"oxy1 chunk 5\0");
        assert_eq!(header(ObjectType::Change, 1234), b"oxy1 change 1234\0");
    }

    #[test]
    fn types_are_domain_separated() {
        let body = b"same bytes";
        let a = hash_object(ObjectType::Chunk, body);
        let b = hash_object(ObjectType::Blob, body);
        assert_ne!(a, b);
        assert_eq!(a, hash_object(ObjectType::Chunk, body));
        // Reference vector: pin so the format cannot drift silently.
        assert_eq!(
            hash_object(ObjectType::Chunk, b"").to_hex(),
            blake3::hash(b"oxy1 chunk 0\0").to_hex().as_str()
        );
    }

    #[test]
    fn hex_round_trip() {
        let r = hash_object(ObjectType::Chunk, b"x");
        assert_eq!(ObjectRef::from_hex(&r.to_hex()), Some(r));
        assert_eq!(ObjectRef::from_hex("zz"), None);
        assert!(r.starts_with_hex(&r.short(7)));
        assert!(ObjectRef::ZERO.is_zero());
        for t in ObjectType::ALL {
            assert_eq!(ObjectType::from_name(t.name()), Some(t));
        }
    }
}

1		//! Object references: BLAKE3-256 over a domain-separating header and the body
2		//! (spec §5.2).
3
4		use std::fmt;
5
6		#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
7		pub struct ObjectRef(pub [u8; 32]);
8
9		/// A change is referenced by the ObjectRef of its encoding.
10		pub type ChangeHash = ObjectRef;
11		/// An identity is referenced by the ObjectRef of its encoding.
12		pub type KeyId = ObjectRef;
13
14		impl ObjectRef {
15		/// Reserved: means "this change" inside a change (spec §5.2, §7.4).
16		pub const ZERO: ObjectRef = ObjectRef([0; 32]);
17
18	30899×	pub fn is_zero(&self) -> bool {
19	30899×	*self == Self::ZERO
20	30899×	}
21	121988×	pub fn to_hex(&self) -> String {
22	121988×	hex::encode(self.0)
23	121988×	}
24	33879×	pub fn from_hex(s: &str) -> Option<ObjectRef> {
25	33879×	let v = hex::decode(s).ok()?;
26	33875×	let a: [u8; 32] = v.try_into().ok()?;
27	33875×	Some(ObjectRef(a))
28	33879×	}
29	155093×	pub fn from_slice(b: &[u8]) -> Option<ObjectRef> {
30	155093×	let a: [u8; 32] = b.try_into().ok()?;
31	155093×	Some(ObjectRef(a))
32	155093×	}
33		/// First `n` hex characters.
34	3355×	pub fn short(&self, n: usize) -> String {
35	3355×	let h = self.to_hex();
36	3355×	h[..n.min(h.len())].to_string()
37	3355×	}
38	113×	pub fn starts_with_hex(&self, prefix: &str) -> bool {
39	113×	self.to_hex().starts_with(prefix)
40	113×	}
41		}
42
43		impl fmt::Display for ObjectRef {
44	120×	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
45	120×	f.write_str(&self.to_hex())
46	120×	}
47		}
48
49		impl fmt::Debug for ObjectRef {
50	2634×	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
51	2634×	write!(f, "#{}", self.short(12))
52	2634×	}
53		}
54
55		#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
56		pub enum ObjectType {
57		Chunk,
58		Blob,
59		Change,
60		Checkpoint,
61		Op,
62		Attest,
63		Identity,
64		Policy,
65		State,
66		Receipt,
67		}
68
69		impl ObjectType {
70		pub const ALL: [ObjectType; 10] = [
71		ObjectType::Chunk,
72		ObjectType::Blob,
73		ObjectType::Change,
74		ObjectType::Checkpoint,
75		ObjectType::Op,
76		ObjectType::Attest,
77		ObjectType::Identity,
78		ObjectType::Policy,
79		ObjectType::State,
80		ObjectType::Receipt,
81		];
82
83	320044×	pub fn name(self) -> &'static str {
84	320044×	match self {
85	80091×	ObjectType::Chunk => "chunk",
86	47272×	ObjectType::Blob => "blob",
87	75860×	ObjectType::Change => "change",
88	24463×	ObjectType::Checkpoint => "checkpoint",
89	51440×	ObjectType::Op => "op",
90	8835×	ObjectType::Attest => "attest",
91	8297×	ObjectType::Identity => "identity",
92	6309×	ObjectType::Policy => "policy",
93	17430×	ObjectType::State => "state",
94	47×	ObjectType::Receipt => "receipt",
95		}
96	320044×	}
97
98	46406×	pub fn from_name(s: &str) -> Option<ObjectType> {
99	203926×	Self::ALL.iter().copied().find(\|t\| t.name() == s)
100	46406×	}
101		}
102
103		/// `ObjectRef = BLAKE3-256("oxy1 " \|\| type \|\| " " \|\| decimal(len) \|\| 0x00 \|\| body)`.
104	104579×	pub fn hash_object(ty: ObjectType, body: &[u8]) -> ObjectRef {
105	104579×	let mut h = blake3::Hasher::new();
106	104579×	h.update(&header(ty, body.len()));
107	104579×	h.update(body);
108	104579×	ObjectRef(*h.finalize().as_bytes())
109	104579×	}
110
111	116023×	pub fn header(ty: ObjectType, len: usize) -> Vec<u8> {
112	116023×	let mut v = Vec::with_capacity(32);
113	116023×	v.extend_from_slice(b"oxy1 ");
114	116023×	v.extend_from_slice(ty.name().as_bytes());
115	116023×	v.push(b' ');
116	116023×	v.extend_from_slice(len.to_string().as_bytes());
117	116023×	v.push(0);
118	116023×	v
119	116023×	}
120
121		#[cfg(test)]
122		mod tests {
123		use super::*;
124
125		#[test]
126	1×	fn header_matches_spec() {
127	1×	assert_eq!(header(ObjectType::Chunk, 5), b"oxy1 chunk 5\0");
128	1×	assert_eq!(header(ObjectType::Change, 1234), b"oxy1 change 1234\0");
129	1×	}
130
131		#[test]
132	1×	fn types_are_domain_separated() {
133	1×	let body = b"same bytes";
134	1×	let a = hash_object(ObjectType::Chunk, body);
135	1×	let b = hash_object(ObjectType::Blob, body);
136	1×	assert_ne!(a, b);
137	1×	assert_eq!(a, hash_object(ObjectType::Chunk, body));
138		// Reference vector: pin so the format cannot drift silently.
139	1×	assert_eq!(
140	1×	hash_object(ObjectType::Chunk, b"").to_hex(),
141	1×	blake3::hash(b"oxy1 chunk 0\0").to_hex().as_str()
142		);
143	1×	}
144
145		#[test]
146	1×	fn hex_round_trip() {
147	1×	let r = hash_object(ObjectType::Chunk, b"x");
148	1×	assert_eq!(ObjectRef::from_hex(&r.to_hex()), Some(r));
149	1×	assert_eq!(ObjectRef::from_hex("zz"), None);
150	1×	assert!(r.starts_with_hex(&r.short(7)));
151	1×	assert!(ObjectRef::ZERO.is_zero());
152	10×	for t in ObjectType::ALL {
153	10×	assert_eq!(ObjectType::from_name(t.name()), Some(t));
154		}
155	1×	}
156		}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/oxy-core/src/hash.rs 100.0%

Keyboard