Merge pull request GitoxideLabs#2332 from cruessler/make-sha-1-optional

Make sha1 optional in `gix-hash`

Author: Byron

gix-hash/Cargo.toml

@@ -18,7 +18,7 @@ test = false
 [features]
 default = ["sha1"]
 ## Support for SHA1 hashes and digests.
-sha1 = []
+sha1 = ["dep:sha1-checked"]
 ## Support for SHA256 hashes and digests.
 sha256 = ["dep:sha2"]
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
@@ -30,7 +30,7 @@ gix-features = { version = "^0.45.1", path = "../gix-features", features = ["pro
 thiserror = "2.0.17"
 faster-hex = { version = "0.10.0", default-features = false, features = ["std"] }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
-sha1-checked = { version = "0.10.0", default-features = false }
+sha1-checked = { version = "0.10.0", optional = true, default-features = false }
 sha2 = { version = "0.10.0", optional = true, default-features = false }
 
 document-features = { version = "0.2.0", optional = true }

gix-hash/src/hasher.rs

@@ -7,8 +7,12 @@ pub enum Error {
 }
 
 pub(super) mod _impl {
+    #[cfg(feature = "sha1")]
     use sha1_checked::{CollisionResult, Digest};
 
+    #[cfg(all(not(feature = "sha1"), feature = "sha256"))]
+    use sha2::Digest;
+
     use crate::hasher::Error;
 
     /// Hash implementations that can be used once.
@@ -17,6 +21,7 @@ pub(super) mod _impl {
         /// An implementation of the SHA1 hash.
         ///
         /// We use [`sha1_checked`] to implement the same collision detection algorithm as Git.
+        #[cfg(feature = "sha1")]
         Sha1(sha1_checked::Sha1),
         /// An implementation of the SHA256 hash.
         #[cfg(feature = "sha256")]
@@ -25,6 +30,7 @@ pub(super) mod _impl {
 
     impl Hasher {
         /// Let's not make this public to force people to go through [`hasher()`].
+        #[cfg(feature = "sha1")]
         fn new_sha1() -> Self {
             // This matches the configuration used by Git, which only uses
             // the collision detection to bail out, rather than computing
@@ -44,6 +50,7 @@ pub(super) mod _impl {
         /// Digest the given `bytes`.
         pub fn update(&mut self, bytes: &[u8]) {
             match self {
+                #[cfg(feature = "sha1")]
                 Hasher::Sha1(sha1) => sha1.update(bytes),
                 #[cfg(feature = "sha256")]
                 Hasher::Sha256(sha256) => sha256.update(bytes),
@@ -59,6 +66,7 @@ pub(super) mod _impl {
         #[inline]
         pub fn try_finalize(self) -> Result<crate::ObjectId, Error> {
             match self {
+                #[cfg(feature = "sha1")]
                 Hasher::Sha1(sha1) => match sha1.try_finalize() {
                     CollisionResult::Ok(digest) => Ok(crate::ObjectId::Sha1(digest.into())),
                     CollisionResult::Mitigated(_) => {
@@ -89,6 +97,7 @@ pub(super) mod _impl {
     #[inline]
     pub fn hasher(kind: crate::Kind) -> Hasher {
         match kind {
+            #[cfg(feature = "sha1")]
             crate::Kind::Sha1 => Hasher::new_sha1(),
             #[cfg(feature = "sha256")]
             crate::Kind::Sha256 => Hasher::new_sha256(),

gix-hash/src/io.rs

@@ -114,6 +114,7 @@ pub(super) mod _impl {
         /// Create a new hash writer which hashes all bytes written to `inner` with a hash of `kind`.
         pub fn new(inner: T, object_hash: crate::Kind) -> Self {
             match object_hash {
+                #[cfg(feature = "sha1")]
                 crate::Kind::Sha1 => Write {
                     inner,
                     hash: crate::hasher(object_hash),

gix-hash/src/kind.rs

@@ -1,6 +1,9 @@
 use std::str::FromStr;
 
-use crate::{oid, Kind, ObjectId, SIZE_OF_SHA1_DIGEST, SIZE_OF_SHA1_HEX_DIGEST};
+use crate::{oid, Kind, ObjectId};
+
+#[cfg(feature = "sha1")]
+use crate::{SIZE_OF_SHA1_DIGEST, SIZE_OF_SHA1_HEX_DIGEST};
 
 #[cfg(feature = "sha256")]
 use crate::{SIZE_OF_SHA256_DIGEST, SIZE_OF_SHA256_HEX_DIGEST};
@@ -10,6 +13,7 @@ impl TryFrom<u8> for Kind {
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         Ok(match value {
+            #[cfg(feature = "sha1")]
             1 => Kind::Sha1,
             #[cfg(feature = "sha256")]
             2 => Kind::Sha256,
@@ -23,6 +27,7 @@ impl FromStr for Kind {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Ok(match s {
+            #[cfg(feature = "sha1")]
             "sha1" | "SHA1" | "SHA-1" => Kind::Sha1,
             #[cfg(feature = "sha256")]
             "sha256" | "SHA256" | "SHA-256" => Kind::Sha256,
@@ -34,6 +39,7 @@ impl FromStr for Kind {
 impl std::fmt::Display for Kind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => f.write_str("sha1"),
             #[cfg(feature = "sha256")]
             Kind::Sha256 => f.write_str("sha256"),
@@ -84,6 +90,7 @@ impl Kind {
     #[inline]
     pub const fn len_in_hex(&self) -> usize {
         match self {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => SIZE_OF_SHA1_HEX_DIGEST,
             #[cfg(feature = "sha256")]
             Kind::Sha256 => SIZE_OF_SHA256_HEX_DIGEST,
@@ -94,6 +101,7 @@ impl Kind {
     #[inline]
     pub const fn len_in_bytes(&self) -> usize {
         match self {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => SIZE_OF_SHA1_DIGEST,
             #[cfg(feature = "sha256")]
             Kind::Sha256 => SIZE_OF_SHA256_DIGEST,
@@ -106,6 +114,7 @@ impl Kind {
     #[inline]
     pub const fn from_hex_len(hex_len: usize) -> Option<Self> {
         Some(match hex_len {
+            #[cfg(feature = "sha1")]
             0..=SIZE_OF_SHA1_HEX_DIGEST => Kind::Sha1,
             #[cfg(feature = "sha256")]
             0..=SIZE_OF_SHA256_HEX_DIGEST => Kind::Sha256,
@@ -124,6 +133,7 @@ impl Kind {
     #[inline]
     pub(crate) fn from_len_in_bytes(bytes: usize) -> Self {
         match bytes {
+            #[cfg(feature = "sha1")]
             SIZE_OF_SHA1_DIGEST => Kind::Sha1,
             #[cfg(feature = "sha256")]
             SIZE_OF_SHA256_DIGEST => Kind::Sha256,
@@ -135,6 +145,7 @@ impl Kind {
     #[inline]
     pub fn null_ref(&self) -> &'static oid {
         match self {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => oid::null_sha1(),
             #[cfg(feature = "sha256")]
             Kind::Sha256 => oid::null_sha256(),
@@ -145,6 +156,7 @@ impl Kind {
     #[inline]
     pub const fn null(&self) -> ObjectId {
         match self {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => ObjectId::null_sha1(),
             #[cfg(feature = "sha256")]
             Kind::Sha256 => ObjectId::null_sha256(),

gix-hash/src/lib.rs

@@ -9,10 +9,8 @@
 #![cfg_attr(all(doc, feature = "document-features"), feature(doc_cfg))]
 #![deny(missing_docs, rust_2018_idioms, unsafe_code)]
 
-// Remove this once other hashes (e.g., SHA256, and potentially others)
-// are supported, and this crate can build without [`ObjectId::Sha1`].
-#[cfg(not(feature = "sha1"))]
-compile_error!("Please set the `sha1` feature flag");
+#[cfg(all(not(feature = "sha1"), not(feature = "sha256")))]
+compile_error!("Please set either the `sha1` or the `sha256` feature flag");
 
 #[path = "oid.rs"]
 mod borrowed;
@@ -47,8 +45,10 @@ pub struct Prefix {
 }
 
 /// The size of a SHA1 hash digest in bytes.
+#[cfg(feature = "sha1")]
 const SIZE_OF_SHA1_DIGEST: usize = 20;
 /// The size of a SHA1 hash digest in hex.
+#[cfg(feature = "sha1")]
 const SIZE_OF_SHA1_HEX_DIGEST: usize = 2 * SIZE_OF_SHA1_DIGEST;
 
 /// The size of a SHA256 hash digest in bytes.
@@ -58,8 +58,10 @@ const SIZE_OF_SHA256_DIGEST: usize = 32;
 #[cfg(feature = "sha256")]
 const SIZE_OF_SHA256_HEX_DIGEST: usize = 2 * SIZE_OF_SHA256_DIGEST;
 
+#[cfg(feature = "sha1")]
 const EMPTY_BLOB_SHA1: &[u8; SIZE_OF_SHA1_DIGEST] =
     b"\xe6\x9d\xe2\x9b\xb2\xd1\xd6\x43\x4b\x8b\x29\xae\x77\x5a\xd8\xc2\xe4\x8c\x53\x91";
+#[cfg(feature = "sha1")]
 const EMPTY_TREE_SHA1: &[u8; SIZE_OF_SHA1_DIGEST] =
     b"\x4b\x82\x5d\xc6\x42\xcb\x6e\xb9\xa0\x60\xe5\x4b\xf8\xd6\x92\x88\xfb\xee\x49\x04";
 
@@ -74,9 +76,11 @@ const EMPTY_TREE_SHA256: &[u8; SIZE_OF_SHA256_DIGEST] = b"\x6e\xf1\x9b\x41\x22\x
 #[non_exhaustive]
 pub enum Kind {
     /// The SHA1 hash with 160 bits.
-    #[default]
+    #[cfg_attr(feature = "sha1", default)]
+    #[cfg(feature = "sha1")]
     Sha1 = 1,
     /// The SHA256 hash with 256 bits.
+    #[cfg_attr(all(not(feature = "sha1"), feature = "sha256"), default)]
     #[cfg(feature = "sha256")]
     Sha256 = 2,
 }

gix-hash/src/object_id.rs

@@ -4,7 +4,10 @@ use std::{
     ops::Deref,
 };
 
-use crate::{borrowed::oid, Kind, EMPTY_BLOB_SHA1, EMPTY_TREE_SHA1, SIZE_OF_SHA1_DIGEST};
+use crate::{borrowed::oid, Kind};
+
+#[cfg(feature = "sha1")]
+use crate::{EMPTY_BLOB_SHA1, EMPTY_TREE_SHA1, SIZE_OF_SHA1_DIGEST};
 
 #[cfg(feature = "sha256")]
 use crate::{EMPTY_BLOB_SHA256, EMPTY_TREE_SHA256, SIZE_OF_SHA256_DIGEST};
@@ -15,6 +18,7 @@ use crate::{EMPTY_BLOB_SHA256, EMPTY_TREE_SHA256, SIZE_OF_SHA256_DIGEST};
 #[non_exhaustive]
 pub enum ObjectId {
     /// A SHA1 hash digest
+    #[cfg(feature = "sha1")]
     Sha1([u8; SIZE_OF_SHA1_DIGEST]),
     /// A SHA256 hash digest
     #[cfg(feature = "sha256")]
@@ -38,7 +42,10 @@ impl Hash for ObjectId {
 pub mod decode {
     use std::str::FromStr;
 
-    use crate::{object_id::ObjectId, SIZE_OF_SHA1_DIGEST, SIZE_OF_SHA1_HEX_DIGEST};
+    use crate::object_id::ObjectId;
+
+    #[cfg(feature = "sha1")]
+    use crate::{SIZE_OF_SHA1_DIGEST, SIZE_OF_SHA1_HEX_DIGEST};
 
     #[cfg(feature = "sha256")]
     use crate::{SIZE_OF_SHA256_DIGEST, SIZE_OF_SHA256_HEX_DIGEST};
@@ -62,6 +69,7 @@ pub mod decode {
         /// Such a buffer can be obtained using [`oid::write_hex_to(buffer)`][super::oid::write_hex_to()]
         pub fn from_hex(buffer: &[u8]) -> Result<ObjectId, Error> {
             match buffer.len() {
+                #[cfg(feature = "sha1")]
                 SIZE_OF_SHA1_HEX_DIGEST => Ok({
                     ObjectId::Sha1({
                         let mut buf = [0; SIZE_OF_SHA1_DIGEST];
@@ -107,6 +115,7 @@ impl ObjectId {
     #[inline]
     pub fn kind(&self) -> Kind {
         match self {
+            #[cfg(feature = "sha1")]
             ObjectId::Sha1(_) => Kind::Sha1,
             #[cfg(feature = "sha256")]
             ObjectId::Sha256(_) => Kind::Sha256,
@@ -116,6 +125,7 @@ impl ObjectId {
     #[inline]
     pub fn as_slice(&self) -> &[u8] {
         match self {
+            #[cfg(feature = "sha1")]
             Self::Sha1(b) => b.as_ref(),
             #[cfg(feature = "sha256")]
             Self::Sha256(b) => b.as_ref(),
@@ -125,6 +135,7 @@ impl ObjectId {
     #[inline]
     pub fn as_mut_slice(&mut self) -> &mut [u8] {
         match self {
+            #[cfg(feature = "sha1")]
             Self::Sha1(b) => b.as_mut(),
             #[cfg(feature = "sha256")]
             Self::Sha256(b) => b.as_mut(),
@@ -135,6 +146,7 @@ impl ObjectId {
     #[inline]
     pub const fn empty_blob(hash: Kind) -> ObjectId {
         match hash {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => ObjectId::Sha1(*EMPTY_BLOB_SHA1),
             #[cfg(feature = "sha256")]
             Kind::Sha256 => ObjectId::Sha256(*EMPTY_BLOB_SHA256),
@@ -145,6 +157,7 @@ impl ObjectId {
     #[inline]
     pub const fn empty_tree(hash: Kind) -> ObjectId {
         match hash {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => ObjectId::Sha1(*EMPTY_TREE_SHA1),
             #[cfg(feature = "sha256")]
             Kind::Sha256 => ObjectId::Sha256(*EMPTY_TREE_SHA256),
@@ -156,6 +169,7 @@ impl ObjectId {
     #[doc(alias = "zero", alias = "git2")]
     pub const fn null(kind: Kind) -> ObjectId {
         match kind {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => Self::null_sha1(),
             #[cfg(feature = "sha256")]
             Kind::Sha256 => Self::null_sha256(),
@@ -167,6 +181,7 @@ impl ObjectId {
     #[doc(alias = "is_zero", alias = "git2")]
     pub fn is_null(&self) -> bool {
         match self {
+            #[cfg(feature = "sha1")]
             ObjectId::Sha1(digest) => &digest[..] == oid::null_sha1().as_bytes(),
             #[cfg(feature = "sha256")]
             ObjectId::Sha256(digest) => &digest[..] == oid::null_sha256().as_bytes(),
@@ -193,6 +208,7 @@ impl ObjectId {
     /// Use `Self::try_from(bytes)` for a fallible version.
     pub fn from_bytes_or_panic(bytes: &[u8]) -> Self {
         match bytes.len() {
+            #[cfg(feature = "sha1")]
             SIZE_OF_SHA1_DIGEST => Self::Sha1(bytes.try_into().expect("prior length validation")),
             #[cfg(feature = "sha256")]
             SIZE_OF_SHA256_DIGEST => Self::Sha256(bytes.try_into().expect("prior length validation")),
@@ -205,6 +221,7 @@ impl ObjectId {
 impl ObjectId {
     /// Instantiate an `ObjectId` from a 20 bytes SHA1 digest.
     #[inline]
+    #[cfg(feature = "sha1")]
     fn new_sha1(id: [u8; SIZE_OF_SHA1_DIGEST]) -> Self {
         ObjectId::Sha1(id)
     }
@@ -220,6 +237,7 @@ impl ObjectId {
     ///
     /// Panics if the slice doesn't have a length of 20.
     #[inline]
+    #[cfg(feature = "sha1")]
     pub(crate) fn from_20_bytes(b: &[u8]) -> ObjectId {
         let mut id = [0; SIZE_OF_SHA1_DIGEST];
         id.copy_from_slice(b);
@@ -239,6 +257,7 @@ impl ObjectId {
 
     /// Returns an `ObjectId` representing a SHA1 whose memory is zeroed.
     #[inline]
+    #[cfg(feature = "sha1")]
     pub(crate) const fn null_sha1() -> ObjectId {
         ObjectId::Sha1([0u8; SIZE_OF_SHA1_DIGEST])
     }
@@ -254,6 +273,7 @@ impl ObjectId {
 impl std::fmt::Debug for ObjectId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
+            #[cfg(feature = "sha1")]
             ObjectId::Sha1(_hash) => f.write_str("Sha1(")?,
             #[cfg(feature = "sha256")]
             ObjectId::Sha256(_) => f.write_str("Sha256(")?,
@@ -265,6 +285,7 @@ impl std::fmt::Debug for ObjectId {
     }
 }
 
+#[cfg(feature = "sha1")]
 impl From<[u8; SIZE_OF_SHA1_DIGEST]> for ObjectId {
     fn from(v: [u8; SIZE_OF_SHA1_DIGEST]) -> Self {
         Self::new_sha1(v)
@@ -281,6 +302,7 @@ impl From<[u8; SIZE_OF_SHA256_DIGEST]> for ObjectId {
 impl From<&oid> for ObjectId {
     fn from(v: &oid) -> Self {
         match v.kind() {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => ObjectId::from_20_bytes(v.as_bytes()),
             #[cfg(feature = "sha256")]
             Kind::Sha256 => ObjectId::from_32_bytes(v.as_bytes()),