feature gate sha

Cargo.toml

@@ -18,7 +18,7 @@ rand = { version = "0.8.5", default-features = false, features = ["std", "std_rn
 thiserror = { version = "1.0", default-features = false }
 strum = { version = "0.25", default-features = false, features = ["std", "derive"] }
 itertools = { version = "0.12", default-features = false, features = ["use_std"]  }
-iota-crypto = { version = "0.23", default-features = false, features = ["std", "sha"] }
+iota-crypto = { version = "0.23", default-features = false, features = ["sha"], optional = true }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 
 [dev-dependencies]
@@ -27,3 +27,6 @@ josekit = "0.8.4"
 [[example]]
 name = "sd_jwt"
 
+[features]
+default = ["sha"]
+sha = ["iota-crypto"]

examples/sd_jwt.rs

@@ -78,7 +78,7 @@ fn main() {
   let (payload, _header) = jwt::decode_with_verifier(&sd_jwt.jwt, &verifier).unwrap();
 
   // Decode the payload by providing the disclosures that were parsed from the SD-JWT.
-  let decoder = SdObjectDecoder::new();
+  let decoder = SdObjectDecoder::new_with_sha256();
   let decoded = decoder.decode(payload.claims_set(), &sd_jwt.disclosures).unwrap();
   println!("decoded object: {}", serde_json::to_string_pretty(&decoded).unwrap());
 }

src/api_test.rs

@@ -115,7 +115,7 @@ fn test_complex_structure() {
   let (payload, _header) = jwt::decode_with_verifier(&sd_jwt.jwt, &verifier).unwrap();
 
   // Decode the payload by providing the disclosures that were parsed from the SD-JWT.
-  let decoder = SdObjectDecoder::new();
+  let decoder = SdObjectDecoder::new_with_sha256();
   let decoded = decoder.decode(payload.claims_set(), &sd_jwt.disclosures).unwrap();
   println!("decoded object: {}", serde_json::to_string_pretty(&decoded).unwrap());
   assert_eq!(Value::Object(decoded), object);
@@ -156,7 +156,7 @@ fn concealed_object_in_array() {
     .into_iter()
     .map(|disclosure| disclosure.to_string())
     .collect();
-  let decoder = SdObjectDecoder::new();
+  let decoder = SdObjectDecoder::new_with_sha256();
   let decoded = decoder.decode(encoder.object(), &disclosures).unwrap();
   assert_eq!(Value::Object(decoded), expected);
 }

src/decoder.rs

@@ -4,9 +4,11 @@
 use crate::ARRAY_DIGEST_KEY;
 use crate::DIGESTS_KEY;
 use crate::SD_ALG;
+use crate::SHA_ALG_NAME;
 
 use super::Disclosure;
 use super::Hasher;
+#[cfg(feature = "sha")]
 use super::Sha256Hasher;
 use crate::Error;
 use serde_json::Map;
@@ -20,13 +22,20 @@ pub struct SdObjectDecoder {
 
 impl SdObjectDecoder {
   /// Creates a new [`SdObjectDecoder`] with `sha-256` hasher.
-  pub fn new() -> Self {
+  #[cfg(feature = "sha")]
+  pub fn new_with_sha256() -> Self {
     let hashers: BTreeMap<String, Box<dyn Hasher>> = BTreeMap::new();
     let mut hasher = Self { hashers };
     hasher.add_hasher(Box::new(Sha256Hasher::new()));
     hasher
   }
 
+  /// Creates a new [`SdObjectDecoder`] without any hashers.
+  pub fn new() -> Self {
+    let hashers: BTreeMap<String, Box<dyn Hasher>> = BTreeMap::new();
+    Self { hashers }
+  }
+
   /// Adds a hasher.
   ///
   /// If a hasher for the same algorithm [`Hasher::alg_name`] already exists, it will be replaced and
@@ -87,7 +96,7 @@ impl SdObjectDecoder {
         "the value of `_sd_alg` is not a string".to_string(),
       ))?
     } else {
-      Sha256Hasher::ALG_NAME
+      SHA_ALG_NAME
     };
     self
       .hashers
@@ -227,9 +236,10 @@ impl SdObjectDecoder {
   }
 }
 
+#[cfg(feature = "sha")]
 impl Default for SdObjectDecoder {
   fn default() -> Self {
-    Self::new()
+    Self::new_with_sha256()
   }
 }
 
@@ -251,7 +261,7 @@ mod test {
     encoder
       .object_mut()
       .insert("id".to_string(), Value::String("id-value".to_string()));
-    let decoder = SdObjectDecoder::new();
+    let decoder = SdObjectDecoder::new_with_sha256();
     let decoded = decoder.decode(encoder.object(), &vec![dis.to_string()]).unwrap_err();
     assert!(matches!(decoded, Error::ClaimCollisionError(_)));
   }
@@ -267,7 +277,7 @@ mod test {
     let mut encoder = SdObjectEncoder::try_from(object).unwrap();
     encoder.add_sd_alg_property();
     assert_eq!(encoder.object().get("_sd_alg").unwrap(), "sha-256");
-    let decoder = SdObjectDecoder::new();
+    let decoder = SdObjectDecoder::new_with_sha256();
     let decoded = decoder.decode(encoder.object(), &vec![]).unwrap();
     assert!(decoded.get("_sd_alg").is_none());
   }

src/encoder.rs

@@ -3,6 +3,7 @@
 
 use super::Disclosure;
 use super::Hasher;
+#[cfg(feature = "sha")]
 use super::Sha256Hasher;
 use crate::Error;
 use crate::Result;
@@ -18,6 +19,20 @@ pub(crate) const SD_ALG: &str = "_sd_alg";
 
 /// Transforms a JSON object into an SD-JWT object by substituting selected values
 /// with their corresponding disclosure digests.
+#[cfg(not(feature = "sha"))]
+pub struct SdObjectEncoder<H: Hasher> {
+  /// The object in JSON format.
+  object: Map<String, Value>,
+  /// Size of random data used to generate the salts for disclosures in bytes.
+  /// Constant length for readability considerations.
+  salt_size: usize,
+  /// The hash function used to create digests.
+  hasher: H,
+}
+
+/// Transforms a JSON object into an SD-JWT object by substituting selected values
+/// with their corresponding disclosure digests.
+#[cfg(feature = "sha")]
 pub struct SdObjectEncoder<H: Hasher = Sha256Hasher> {
   /// The object in JSON format.
   object: Map<String, Value>,
@@ -28,6 +43,7 @@ pub struct SdObjectEncoder<H: Hasher = Sha256Hasher> {
   hasher: H,
 }
 
+#[cfg(feature = "sha")]
 impl SdObjectEncoder {
   /// Creates a new [`SdObjectEncoder`] with `sha-256` hash function.
   ///
@@ -51,6 +67,7 @@ impl SdObjectEncoder {
   }
 }
 
+#[cfg(feature = "sha")]
 impl TryFrom<Value> for SdObjectEncoder {
   type Error = crate::Error;
 

src/hasher.rs

@@ -1,9 +1,14 @@
 // Copyright 2020-2023 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
+#[cfg(feature = "sha")]
 use crypto::hashes::sha::SHA256;
+
+#[cfg(feature = "sha")]
 use crypto::hashes::sha::SHA256_LEN;
 
+pub const SHA_ALG_NAME: &'static str = "sha-256";
+
 /// Used to implement hash functions to be used for encoding/decoding.
 ///
 /// ## Note
@@ -32,16 +37,17 @@ pub trait Hasher: Sync + Send {
 
 /// An implementation of [`Hasher`] that uses the `sha-256` hash function.
 #[derive(Default)]
+#[cfg(feature = "sha")]
 pub struct Sha256Hasher;
 
+#[cfg(feature = "sha")]
 impl Sha256Hasher {
-  pub const ALG_NAME: &'static str = "sha-256";
   /// Creates a new [`ShaHasher`]
   pub fn new() -> Self {
     Sha256Hasher {}
   }
 }
-
+#[cfg(feature = "sha")]
 impl Hasher for Sha256Hasher {
   fn digest(&self, input: &[u8]) -> Vec<u8> {
     let mut digest: [u8; SHA256_LEN] = Default::default();
@@ -50,7 +56,7 @@ impl Hasher for Sha256Hasher {
   }
 
   fn alg_name(&self) -> &'static str {
-    Sha256Hasher::ALG_NAME
+    SHA_ALG_NAME
   }
 }