hash.rs 100.0%

85 of 85 lines run, 28 of 29 functions · run #318 on main · 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,
    /// A short-lived key's certificate (oxygenhub#241).
    Certificate,
    /// An author's grant to a certified subject (§14.7).
    Grant,
}

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

    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",
            ObjectType::Certificate => "certificate",
            ObjectType::Grant => "grant",
        }
    }

    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	32182×	pub fn is_zero(&self) -> bool {
19	32182×	*self == Self::ZERO
20	32182×	}
21	115291×	pub fn to_hex(&self) -> String {
22	115291×	hex::encode(self.0)
23	115291×	}
24	35858×	pub fn from_hex(s: &str) -> Option<ObjectRef> {
25	35858×	let v = hex::decode(s).ok()?;
26	35854×	let a: [u8; 32] = v.try_into().ok()?;
27	35854×	Some(ObjectRef(a))
28	35858×	}
29	162982×	pub fn from_slice(b: &[u8]) -> Option<ObjectRef> {
30	162982×	let a: [u8; 32] = b.try_into().ok()?;
31	162982×	Some(ObjectRef(a))
32	162982×	}
33		/// First `n` hex characters.
34	3394×	pub fn short(&self, n: usize) -> String {
35	3394×	let h = self.to_hex();
36	3394×	h[..n.min(h.len())].to_string()
37	3394×	}
38	119×	pub fn starts_with_hex(&self, prefix: &str) -> bool {
39	119×	self.to_hex().starts_with(prefix)
40	119×	}
41		}
42
43		impl fmt::Display for ObjectRef {
44	121×	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
45	121×	f.write_str(&self.to_hex())
46	121×	}
47		}
48
49		impl fmt::Debug for ObjectRef {
50	2646×	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
51	2646×	write!(f, "#{}", self.short(12))
52	2646×	}
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		/// A short-lived key's certificate (oxygenhub#241).
68		Certificate,
69		/// An author's grant to a certified subject (§14.7).
70		Grant,
71		}
72
73		impl ObjectType {
74		pub const ALL: [ObjectType; 12] = [
75		ObjectType::Chunk,
76		ObjectType::Blob,
77		ObjectType::Change,
78		ObjectType::Checkpoint,
79		ObjectType::Op,
80		ObjectType::Attest,
81		ObjectType::Identity,
82		ObjectType::Policy,
83		ObjectType::State,
84		ObjectType::Receipt,
85		ObjectType::Certificate,
86		ObjectType::Grant,
87		];
88
89	339947×	pub fn name(self) -> &'static str {
90	339947×	match self {
91	82691×	ObjectType::Chunk => "chunk",
92	49784×	ObjectType::Blob => "blob",
93	79661×	ObjectType::Change => "change",
94	26348×	ObjectType::Checkpoint => "checkpoint",
95	54889×	ObjectType::Op => "op",
96	10317×	ObjectType::Attest => "attest",
97	10237×	ObjectType::Identity => "identity",
98	7199×	ObjectType::Policy => "policy",
99	18417×	ObjectType::State => "state",
100	131×	ObjectType::Receipt => "receipt",
101	260×	ObjectType::Certificate => "certificate",
102	13×	ObjectType::Grant => "grant",
103		}
104	339947×	}
105
106	48920×	pub fn from_name(s: &str) -> Option<ObjectType> {
107	217985×	Self::ALL.iter().copied().find(\|t\| t.name() == s)
108	48920×	}
109		}
110
111		/// `ObjectRef = BLAKE3-256("oxy1 " \|\| type \|\| " " \|\| decimal(len) \|\| 0x00 \|\| body)`.
112	109747×	pub fn hash_object(ty: ObjectType, body: &[u8]) -> ObjectRef {
113	109747×	let mut h = blake3::Hasher::new();
114	109747×	h.update(&header(ty, body.len()));
115	109747×	h.update(body);
116	109747×	ObjectRef(*h.finalize().as_bytes())
117	109747×	}
118
119	121856×	pub fn header(ty: ObjectType, len: usize) -> Vec<u8> {
120	121856×	let mut v = Vec::with_capacity(32);
121	121856×	v.extend_from_slice(b"oxy1 ");
122	121856×	v.extend_from_slice(ty.name().as_bytes());
123	121856×	v.push(b' ');
124	121856×	v.extend_from_slice(len.to_string().as_bytes());
125	121856×	v.push(0);
126	121856×	v
127	121856×	}
128
129		#[cfg(test)]
130		mod tests {
131		use super::*;
132
133		#[test]
134	1×	fn header_matches_spec() {
135	1×	assert_eq!(header(ObjectType::Chunk, 5), b"oxy1 chunk 5\0");
136	1×	assert_eq!(header(ObjectType::Change, 1234), b"oxy1 change 1234\0");
137	1×	}
138
139		#[test]
140	1×	fn types_are_domain_separated() {
141	1×	let body = b"same bytes";
142	1×	let a = hash_object(ObjectType::Chunk, body);
143	1×	let b = hash_object(ObjectType::Blob, body);
144	1×	assert_ne!(a, b);
145	1×	assert_eq!(a, hash_object(ObjectType::Chunk, body));
146		// Reference vector: pin so the format cannot drift silently.
147	1×	assert_eq!(
148	1×	hash_object(ObjectType::Chunk, b"").to_hex(),
149	1×	blake3::hash(b"oxy1 chunk 0\0").to_hex().as_str()
150		);
151	1×	}
152
153		#[test]
154	1×	fn hex_round_trip() {
155	1×	let r = hash_object(ObjectType::Chunk, b"x");
156	1×	assert_eq!(ObjectRef::from_hex(&r.to_hex()), Some(r));
157	1×	assert_eq!(ObjectRef::from_hex("zz"), None);
158	1×	assert!(r.starts_with_hex(&r.short(7)));
159	1×	assert!(ObjectRef::ZERO.is_zero());
160	12×	for t in ObjectType::ALL {
161	12×	assert_eq!(ObjectType::from_name(t.name()), Some(t));
162		}
163	1×	}
164		}

`/`	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