nix_compat/nixhash/
ca_hash.rs

1use crate::nixbase32;
2use crate::nixhash::{HashAlgo, NixHash};
3use serde::de::Unexpected;
4use serde::ser::SerializeMap;
5use serde::{Deserialize, Deserializer, Serialize, Serializer};
6use serde_json::{Map, Value};
7use std::borrow::Cow;
8
9use super::algos::SUPPORTED_ALGOS;
10use super::decode_digest;
11
12/// A Nix CAHash describes a content-addressed hash of a path.
13///
14/// The way Nix prints it as a string is a bit confusing, but there's essentially
15/// three modes, `Flat`, `Nar` and `Text`.
16/// `Flat` and `Nar` support all 4 algos that [NixHash] supports
17/// (sha1, md5, sha256, sha512), `Text` only supports sha256.
18#[derive(Clone, Debug, Eq, PartialEq)]
19pub enum CAHash {
20    Flat(NixHash),  // "fixed flat"
21    Nar(NixHash),   // "fixed recursive"
22    Text([u8; 32]), // "text", only supports sha256
23}
24
25/// Representation for the supported hash modes.
26#[derive(Debug, Clone, Copy, PartialEq, Eq)]
27pub enum HashMode {
28    Flat,
29    Nar,
30    Text,
31}
32
33impl CAHash {
34    pub fn hash(&self) -> Cow<NixHash> {
35        match *self {
36            CAHash::Flat(ref digest) => Cow::Borrowed(digest),
37            CAHash::Nar(ref digest) => Cow::Borrowed(digest),
38            CAHash::Text(digest) => Cow::Owned(NixHash::Sha256(digest)),
39        }
40    }
41
42    pub fn mode(&self) -> HashMode {
43        match self {
44            CAHash::Flat(_) => HashMode::Flat,
45            CAHash::Nar(_) => HashMode::Nar,
46            CAHash::Text(_) => HashMode::Text,
47        }
48    }
49
50    /// Constructs a [CAHash] from the textual representation,
51    /// which is one of the three:
52    /// - `text:sha256:$nixbase32sha256digest`
53    /// - `fixed:r:$algo:$nixbase32digest`
54    /// - `fixed:$algo:$nixbase32digest`
55    ///
56    /// These formats are used in NARInfo, for example.
57    pub fn from_nix_hex_str(s: &str) -> Option<Self> {
58        let (tag, s) = s.split_once(':')?;
59
60        match tag {
61            "text" => {
62                let digest = s.strip_prefix("sha256:")?;
63                let digest = nixbase32::decode_fixed(digest).ok()?;
64                Some(CAHash::Text(digest))
65            }
66            "fixed" => {
67                if let Some(s) = s.strip_prefix("r:") {
68                    NixHash::from_nix_nixbase32(s).map(CAHash::Nar)
69                } else {
70                    NixHash::from_nix_nixbase32(s).map(CAHash::Flat)
71                }
72            }
73            _ => None,
74        }
75    }
76
77    /// Formats a [CAHash] in the Nix default hash format, which is the format
78    /// that's used in NARInfos for example.
79    pub fn to_nix_nixbase32_string(&self) -> String {
80        format!(
81            "{}:{}",
82            match self.mode() {
83                HashMode::Flat => match self.hash().as_ref() {
84                    NixHash::Md5(_) => "fixed:md5",
85                    NixHash::Sha1(_) => "fixed:sha1",
86                    NixHash::Sha256(_) => "fixed:sha256",
87                    NixHash::Sha512(_) => "fixed:sha512",
88                },
89                HashMode::Nar => match self.hash().as_ref() {
90                    NixHash::Md5(_) => "fixed:r:md5",
91                    NixHash::Sha1(_) => "fixed:r:sha1",
92                    NixHash::Sha256(_) => "fixed:r:sha256",
93                    NixHash::Sha512(_) => "fixed:r:sha512",
94                },
95                HashMode::Text => "text:sha256",
96            },
97            nixbase32::encode(self.hash().digest_as_bytes())
98        )
99    }
100
101    /// This takes a serde_json::Map and turns it into this structure. This is necessary to do such
102    /// shenigans because we have external consumers, like the Derivation parser, who would like to
103    /// know whether we have a invalid or a missing NixHashWithMode structure in another structure,
104    /// e.g. Output.
105    /// This means we have this combinatorial situation:
106    ///
107    /// - no hash, no hashAlgo: no [CAHash] so we return Ok(None).
108    /// - present hash, missing hashAlgo: invalid, we will return missing_field
109    /// - missing hash, present hashAlgo: same
110    /// - present hash, present hashAlgo: either we return ourselves or a type/value validation
111    ///   error.
112    ///
113    /// This function is for internal consumption regarding those needs until we have a better
114    /// solution. Now this is said, let's explain how this works.
115    ///
116    /// We want to map the serde data model into a [CAHash].
117    ///
118    /// The serde data model has a `hash` field (containing a digest in nixbase32),
119    /// and a `hashAlgo` field, containing the stringified hash algo.
120    /// In case the hash is recursive, hashAlgo also has a `r:` prefix.
121    ///
122    /// This is to match how `nix show-derivation` command shows them in JSON
123    /// representation.
124    pub(crate) fn from_map<'de, D>(map: &Map<String, Value>) -> Result<Option<Self>, D::Error>
125    where
126        D: Deserializer<'de>,
127    {
128        // If we don't have hash neither hashAlgo, let's just return None.
129        if !map.contains_key("hash") && !map.contains_key("hashAlgo") {
130            return Ok(None);
131        }
132
133        let hash_algo_v = map.get("hashAlgo").ok_or_else(|| {
134            serde::de::Error::missing_field(
135                "couldn't extract `hashAlgo` key, but `hash` key present",
136            )
137        })?;
138        let hash_algo = hash_algo_v.as_str().ok_or_else(|| {
139            serde::de::Error::invalid_type(Unexpected::Other(&hash_algo_v.to_string()), &"a string")
140        })?;
141        let (mode_is_nar, hash_algo) = if let Some(s) = hash_algo.strip_prefix("r:") {
142            (true, s)
143        } else {
144            (false, hash_algo)
145        };
146        let hash_algo = HashAlgo::try_from(hash_algo).map_err(|e| {
147            serde::de::Error::invalid_value(
148                Unexpected::Other(&e.to_string()),
149                &format!("one of {}", SUPPORTED_ALGOS.join(",")).as_str(),
150            )
151        })?;
152
153        let hash_v = map.get("hash").ok_or_else(|| {
154            serde::de::Error::missing_field(
155                "couldn't extract `hash` key but `hashAlgo` key present",
156            )
157        })?;
158        let hash = hash_v.as_str().ok_or_else(|| {
159            serde::de::Error::invalid_type(Unexpected::Other(&hash_v.to_string()), &"a string")
160        })?;
161        let hash = decode_digest(hash.as_bytes(), hash_algo)
162            .map_err(|e| serde::de::Error::custom(e.to_string()))?;
163        if mode_is_nar {
164            Ok(Some(Self::Nar(hash)))
165        } else {
166            Ok(Some(Self::Flat(hash)))
167        }
168    }
169}
170
171impl Serialize for CAHash {
172    /// map a CAHash into the serde data model.
173    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
174    where
175        S: Serializer,
176    {
177        let mut map = serializer.serialize_map(Some(2))?;
178        match self {
179            CAHash::Flat(h) => {
180                map.serialize_entry("hash", &nixbase32::encode(h.digest_as_bytes()))?;
181                map.serialize_entry("hashAlgo", &h.algo())?;
182            }
183            CAHash::Nar(h) => {
184                map.serialize_entry("hash", &nixbase32::encode(h.digest_as_bytes()))?;
185                map.serialize_entry("hashAlgo", &format!("r:{}", &h.algo()))?;
186            }
187            // It is not legal for derivations to use this (which is where
188            // we're currently exercising [Serialize] mostly,
189            // but it's still good to be able to serialize other CA hashes too.
190            CAHash::Text(h) => {
191                map.serialize_entry("hash", &nixbase32::encode(h.as_ref()))?;
192                map.serialize_entry("hashAlgo", "text")?;
193            }
194        };
195        map.end()
196    }
197}
198
199impl<'de> Deserialize<'de> for CAHash {
200    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
201    where
202        D: Deserializer<'de>,
203    {
204        let value = Self::from_map::<D>(&Map::deserialize(deserializer)?)?;
205
206        match value {
207            None => Err(serde::de::Error::custom("couldn't parse as map")),
208            Some(v) => Ok(v),
209        }
210    }
211}
212
213#[cfg(test)]
214mod tests {
215    use hex_literal::hex;
216
217    use crate::{
218        derivation::CAHash,
219        nixhash::{HashAlgo, NixHash},
220    };
221
222    #[test]
223    fn serialize_flat() {
224        let json_bytes = r#"{
225  "hash": "1fnf2m46ya7r7afkcb8ba2j0sc4a85m749sh9jz64g4hx6z3r088",
226  "hashAlgo": "sha256"
227}"#;
228        let hash = CAHash::Flat(
229            NixHash::from_algo_and_digest(
230                HashAlgo::Sha256,
231                &hex!("08813cbee9903c62be4c5027726a418a300da4500b2d369d3af9286f4815ceba"),
232            )
233            .unwrap(),
234        );
235        let serialized = serde_json::to_string_pretty(&hash).unwrap();
236        assert_eq!(serialized, json_bytes);
237    }
238
239    #[test]
240    fn serialize_nar() {
241        let json_bytes = r#"{
242  "hash": "1fnf2m46ya7r7afkcb8ba2j0sc4a85m749sh9jz64g4hx6z3r088",
243  "hashAlgo": "r:sha256"
244}"#;
245        let hash = CAHash::Nar(
246            NixHash::from_algo_and_digest(
247                HashAlgo::Sha256,
248                &hex!("08813cbee9903c62be4c5027726a418a300da4500b2d369d3af9286f4815ceba"),
249            )
250            .unwrap(),
251        );
252        let serialized = serde_json::to_string_pretty(&hash).unwrap();
253        assert_eq!(serialized, json_bytes);
254    }
255
256    #[test]
257    fn deserialize_flat() {
258        let json_bytes = r#"
259        {
260            "hash": "08813cbee9903c62be4c5027726a418a300da4500b2d369d3af9286f4815ceba",
261            "hashAlgo": "sha256"
262        }"#;
263        let hash: CAHash = serde_json::from_str(json_bytes).expect("must parse");
264
265        assert_eq!(
266            hash,
267            CAHash::Flat(
268                NixHash::from_algo_and_digest(
269                    HashAlgo::Sha256,
270                    &hex!("08813cbee9903c62be4c5027726a418a300da4500b2d369d3af9286f4815ceba")
271                )
272                .unwrap()
273            )
274        );
275    }
276
277    #[test]
278    fn deserialize_hex() {
279        let json_bytes = r#"
280        {
281            "hash": "08813cbee9903c62be4c5027726a418a300da4500b2d369d3af9286f4815ceba",
282            "hashAlgo": "r:sha256"
283        }"#;
284        let hash: CAHash = serde_json::from_str(json_bytes).expect("must parse");
285
286        assert_eq!(
287            hash,
288            CAHash::Nar(
289                NixHash::from_algo_and_digest(
290                    HashAlgo::Sha256,
291                    &hex!("08813cbee9903c62be4c5027726a418a300da4500b2d369d3af9286f4815ceba")
292                )
293                .unwrap()
294            )
295        );
296    }
297
298    #[test]
299    fn deserialize_nixbase32() {
300        let json_bytes = r#"
301        {
302            "hash": "1fnf2m46ya7r7afkcb8ba2j0sc4a85m749sh9jz64g4hx6z3r088",
303            "hashAlgo": "r:sha256"
304        }"#;
305        let hash: CAHash = serde_json::from_str(json_bytes).expect("must parse");
306
307        assert_eq!(
308            hash,
309            CAHash::Nar(
310                NixHash::from_algo_and_digest(
311                    HashAlgo::Sha256,
312                    &hex!("08813cbee9903c62be4c5027726a418a300da4500b2d369d3af9286f4815ceba"),
313                )
314                .unwrap()
315            )
316        );
317    }
318
319    #[test]
320    fn deserialize_base64() {
321        let json_bytes = r#"
322        {
323            "hash": "CIE8vumQPGK+TFAncmpBijANpFALLTadOvkob0gVzro=",
324            "hashAlgo": "r:sha256"
325        }"#;
326        let hash: CAHash = serde_json::from_str(json_bytes).expect("must parse");
327
328        assert_eq!(
329            hash,
330            CAHash::Nar(
331                NixHash::from_algo_and_digest(
332                    HashAlgo::Sha256,
333                    &hex!("08813cbee9903c62be4c5027726a418a300da4500b2d369d3af9286f4815ceba"),
334                )
335                .unwrap()
336            )
337        );
338    }
339
340    #[test]
341    fn serialize_deserialize_nar() {
342        let json_bytes = r#"
343        {
344            "hash": "08813cbee9903c62be4c5027726a418a300da4500b2d369d3af9286f4815ceba",
345            "hashAlgo": "r:sha256"
346        }"#;
347        let hash: CAHash = serde_json::from_str(json_bytes).expect("must parse");
348
349        let serialized = serde_json::to_string(&hash).expect("Serialize");
350        let hash2: CAHash = serde_json::from_str(&serialized).expect("must parse again");
351
352        assert_eq!(hash, hash2);
353    }
354
355    #[test]
356    fn serialize_deserialize_flat() {
357        let json_bytes = r#"
358        {
359            "hash": "08813cbee9903c62be4c5027726a418a300da4500b2d369d3af9286f4815ceba",
360            "hashAlgo": "sha256"
361        }"#;
362        let hash: CAHash = serde_json::from_str(json_bytes).expect("must parse");
363
364        let serialized = serde_json::to_string(&hash).expect("Serialize");
365        let hash2: CAHash = serde_json::from_str(&serialized).expect("must parse again");
366
367        assert_eq!(hash, hash2);
368    }
369}
nix_compat/nixhash/ca_hash.rs

nix_compat/nixhash/
ca_hash.rs
