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

Make sha1 optional in `gix-hash`

Sebastian Thiel committed 10 months ago

Commit 41502032 parents 9e1ba5e aed5b669 files · +81 −12Browse files

Unified · Split

9 files

gix-hash/Cargo.toml +2 −2
gix-hash/src/hasher.rs +9 −0
gix-hash/src/io.rs +1 −0
gix-hash/src/kind.rs +13 −1
gix-hash/src/lib.rs +9 −5
gix-hash/src/object_id.rs +24 −2
gix-hash/src/oid.rs +21 −1
gix-hash/tests/hash/kind.rs +0 −1
justfile +2 −0

@@ -18,7 +18,7 @@ test = false · 17 unmodified lines
18	[features]	18	[features]
19	default = ["sha1"]	19	default = ["sha1"]
20	## Support for SHA1 hashes and digests.	20	## Support for SHA1 hashes and digests.
21	sha1 = []	21	sha1 = ["dep:sha1-checked"]
22	## Support for SHA256 hashes and digests.	22	## Support for SHA256 hashes and digests.
23	sha256 = ["dep:sha2"]	23	sha256 = ["dep:sha2"]
24	## Data structures implement `serde::Serialize` and `serde::Deserialize`.	24	## Data structures implement `serde::Serialize` and `serde::Deserialize`.
@@ -30,7 +30,7 @@ gix-features = { version = "^0.45.1", path = "../gix-features", features = ["pro · 5 unmodified lines
30	thiserror = "2.0.17"	30	thiserror = "2.0.17"
31	faster-hex = { version = "0.10.0", default-features = false, features = ["std"] }	31	faster-hex = { version = "0.10.0", default-features = false, features = ["std"] }
32	serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }	32	serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"] }
33	sha1-checked = { version = "0.10.0", default-features = false }	33	sha1-checked = { version = "0.10.0", optional = true, default-features = false }
34	sha2 = { version = "0.10.0", optional = true, default-features = false }	34	sha2 = { version = "0.10.0", optional = true, default-features = false }
35		35
36	document-features = { version = "0.2.0", optional = true }	36	document-features = { version = "0.2.0", optional = true }

gix-hash/src/hasher.rs+9−0

 }
 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.
         /// 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")]
     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
         /// 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),
         #[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(_) => {
     #[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+1−0

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

gix-hash/src/kind.rs+13−1

 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};
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         Ok(match value {
+            #[cfg(feature = "sha1")]
             1 => Kind::Sha1,
             #[cfg(feature = "sha256")]
             2 => Kind::Sha256,
     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,
 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"),
     #[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,
     #[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,
     #[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,
     #[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,
     #[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(),
     #[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−5

 #![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)
+#[cfg(all(not(feature = "sha1"), not(feature = "sha256")))]
-// are supported, and this crate can build without [`ObjectId::Sha1`].
+compile_error!("Please set either the `sha1` or the `sha256` feature flag");
-#[cfg(not(feature = "sha1"))]
-compile_error!("Please set the `sha1` feature flag");
 #[path = "oid.rs"]
 mod borrowed;
 }
 /// 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.
 #[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";
 #[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+24−2

     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};
 #[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")]
 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};
         /// 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];
     #[inline]
     pub fn kind(&self) -> Kind {
         match self {
+            #[cfg(feature = "sha1")]
             ObjectId::Sha1(_) => Kind::Sha1,
             #[cfg(feature = "sha256")]
             ObjectId::Sha256(_) => Kind::Sha256,
     #[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(),
     #[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(),
     #[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),
     #[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),
     #[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(),
     #[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(),
     /// 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")),
 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)
     }
     ///
     /// 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);
     /// 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])
     }
 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(")?,
     }
 }
+#[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)
 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()),

gix-hash/src/oid.rs+21−1

 use std::hash;
-use crate::{Kind, ObjectId, EMPTY_BLOB_SHA1, EMPTY_TREE_SHA1, SIZE_OF_SHA1_DIGEST};
+use crate::{Kind, ObjectId};
+#[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};
             f,
             "{}({})",
             match self.kind() {
+                #[cfg(feature = "sha1")]
                 Kind::Sha1 => "Sha1",
                 #[cfg(feature = "sha256")]
                 Kind::Sha256 => "Sha256",
     #[inline]
     pub fn try_from_bytes(digest: &[u8]) -> Result<&Self, Error> {
         match digest.len() {
+            #[cfg(feature = "sha1")]
             SIZE_OF_SHA1_DIGEST => Ok(
                 #[allow(unsafe_code)]
                 unsafe {
     #[doc(alias = "is_zero", alias = "git2")]
     pub fn is_null(&self) -> bool {
         match self.kind() {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => &self.bytes == oid::null_sha1().as_bytes(),
             #[cfg(feature = "sha256")]
             Kind::Sha256 => &self.bytes == oid::null_sha256().as_bytes(),
     #[inline]
     pub fn is_empty_blob(&self) -> bool {
         match self.kind() {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => &self.bytes == oid::empty_blob_sha1().as_bytes(),
             #[cfg(feature = "sha256")]
             Kind::Sha256 => &self.bytes == oid::empty_blob_sha256().as_bytes(),
     #[inline]
     pub fn is_empty_tree(&self) -> bool {
         match self.kind() {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => &self.bytes == oid::empty_tree_sha1().as_bytes(),
             #[cfg(feature = "sha256")]
             Kind::Sha256 => &self.bytes == oid::empty_tree_sha256().as_bytes(),
 impl oid {
     /// Returns a SHA1 digest with all bytes being initialized to zero.
     #[inline]
+    #[cfg(feature = "sha1")]
     pub(crate) fn null_sha1() -> &'static Self {
         oid::from_bytes([0u8; SIZE_OF_SHA1_DIGEST].as_ref())
     }
     /// Returns an `oid` representing the SHA1 hash of an empty blob.
     #[inline]
+    #[cfg(feature = "sha1")]
     pub(crate) fn empty_blob_sha1() -> &'static Self {
         oid::from_bytes(EMPTY_BLOB_SHA1)
     }
     /// Returns an `oid` representing the SHA1 hash of an empty tree.
     #[inline]
+    #[cfg(feature = "sha1")]
     pub(crate) fn empty_tree_sha1() -> &'static Self {
         oid::from_bytes(EMPTY_TREE_SHA1)
     }
     fn to_owned(&self) -> Self::Owned {
         match self.kind() {
+            #[cfg(feature = "sha1")]
             Kind::Sha1 => ObjectId::Sha1(self.bytes.try_into().expect("no bug in hash detection")),
             #[cfg(feature = "sha256")]
             Kind::Sha256 => ObjectId::Sha256(self.bytes.try_into().expect("no bug in hash detection")),
     }
 }
+#[cfg(feature = "sha1")]
 impl<'a> From<&'a [u8; SIZE_OF_SHA1_DIGEST]> for &'a oid {
     fn from(v: &'a [u8; SIZE_OF_SHA1_DIGEST]) -> Self {
         oid::from_bytes(v.as_ref())
     }
 }
+#[cfg(feature = "sha256")]
+impl<'a> From<&'a [u8; SIZE_OF_SHA256_DIGEST]> for &'a oid {
+    fn from(v: &'a [u8; SIZE_OF_SHA256_DIGEST]) -> Self {
+        oid::from_bytes(v.as_ref())
+    }
+}
 impl std::fmt::Display for &oid {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut buf = Kind::hex_buf();

gix-hash/tests/hash/kind.rs+0−1

@@ -90,7 +90,6 @@ fn longest_sha1() { · 89 unmodified lines
90	assert_eq!(longest, Kind::Sha1);	90	assert_eq!(longest, Kind::Sha1);
91	}	91	}
92		92
93	// TODO: make sure to test all permutations once `sha1` is fully optional
94	#[test]	93	#[test]
95	#[cfg(all(not(feature = "sha1"), feature = "sha256"))]	94	#[cfg(all(not(feature = "sha1"), feature = "sha256"))]
96	fn longest_sha256() {	95	fn longest_sha256() {

justfile+2−0

     cargo check -p gix-hash --all-features
     cargo check -p gix-hash
     cargo check -p gix-hash --features sha256
+    cargo check -p gix-hash --no-default-features --features sha256
     cargo check -p gix-object --all-features
     cargo check -p gix-object --features verbose-object-parsing-errors
     cargo check -p gix-attributes --features serde
     cargo nextest run -p gix-worktree-tests --features gix-features-parallel --no-fail-fast
     cargo nextest run -p gix-hash --no-fail-fast
     cargo nextest run -p gix-hash --features sha256 --no-fail-fast
+    cargo nextest run -p gix-hash --no-default-features --features sha256 --no-fail-fast # TODO: make this actually work by removing 'sha1' from default features.
     cargo nextest run -p gix-object --no-fail-fast
     cargo nextest run -p gix-object --features verbose-object-parsing-errors --no-fail-fast
     cargo nextest run -p gix-tempfile --features signals --no-fail-fast

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code