feat: support blocking apis

Author: junkurihara

httpsig-hyper/Cargo.toml

@@ -12,6 +12,11 @@ rust-version.workspace = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[features]
+default = ["blocking"]
+blocking = ["futures/executor"]
+
+
 [dependencies]
 httpsig = { path = "../httpsig", version = "0.0.20" }
 

httpsig-hyper/src/hyper_http.rs

@@ -133,6 +133,89 @@ pub trait MessageSignatureRes {
   ) -> Result<IndexMap<SignatureName, (HttpSignatureBase, HttpSignatureHeaders)>, Self::Error>;
 }
 
+/* --------------------------------------- */
+#[cfg(feature = "blocking")]
+/// A trait about http message signature for request with synchronous signing/verifying key
+pub trait MessageSignatureReqSync: MessageSignatureReq {
+  fn set_message_signature_sync<T>(
+    &mut self,
+    signature_params: &HttpSignatureParams,
+    signing_key: &T,
+    signature_name: Option<&str>,
+  ) -> Result<(), Self::Error>
+  where
+    Self: Sized,
+    T: SigningKey + Sync;
+
+  fn set_message_signatures_sync<T>(
+    &mut self,
+    params_key_name: &[(&HttpSignatureParams, &T, Option<&str>)],
+  ) -> Result<(), Self::Error>
+  where
+    Self: Sized,
+    T: SigningKey + Sync;
+
+  fn verify_message_signature_sync<T>(&self, verifying_key: &T, key_id: Option<&str>) -> Result<SignatureName, Self::Error>
+  where
+    Self: Sized,
+    T: VerifyingKey + Sync;
+
+  fn verify_message_signatures_sync<T>(
+    &self,
+    key_and_id: &[(&T, Option<&str>)],
+  ) -> Result<Vec<Result<SignatureName, Self::Error>>, Self::Error>
+  where
+    Self: Sized,
+    T: VerifyingKey + Sync;
+}
+
+#[cfg(feature = "blocking")]
+/// A trait about http message signature for response with synchronous signing/verifying key
+pub trait MessageSignatureResSync: MessageSignatureRes {
+  fn set_message_signature_sync<T, B>(
+    &mut self,
+    signature_params: &HttpSignatureParams,
+    signing_key: &T,
+    signature_name: Option<&str>,
+    req_for_param: Option<&Request<B>>,
+  ) -> Result<(), Self::Error>
+  where
+    Self: Sized,
+    T: SigningKey + Sync,
+    B: Sync;
+
+  fn set_message_signatures_sync<T, B>(
+    &mut self,
+    params_key_name: &[(&HttpSignatureParams, &T, Option<&str>)],
+    req_for_param: Option<&Request<B>>,
+  ) -> Result<(), Self::Error>
+  where
+    Self: Sized,
+    T: SigningKey + Sync,
+    B: Sync;
+
+  fn verify_message_signature_sync<T, B>(
+    &self,
+    verifying_key: &T,
+    key_id: Option<&str>,
+    req_for_param: Option<&Request<B>>,
+  ) -> Result<SignatureName, Self::Error>
+  where
+    Self: Sized,
+    T: VerifyingKey + Sync,
+    B: Sync;
+
+  fn verify_message_signatures_sync<T, B>(
+    &self,
+    key_and_id: &[(&T, Option<&str>)],
+    req_for_param: Option<&Request<B>>,
+  ) -> Result<Vec<Result<SignatureName, Self::Error>>, Self::Error>
+  where
+    Self: Sized,
+    T: VerifyingKey + Sync,
+    B: Sync;
+}
+
 /* --------------------------------------- */
 impl<D> MessageSignature for Request<D>
 where
@@ -378,6 +461,117 @@ where
   }
 }
 
+/* --------------------------------------- */
+#[cfg(feature = "blocking")]
+impl<D> MessageSignatureReqSync for Request<D>
+where
+  D: Send + Body + Sync,
+{
+  fn set_message_signature_sync<T>(
+    &mut self,
+    signature_params: &HttpSignatureParams,
+    signing_key: &T,
+    signature_name: Option<&str>,
+  ) -> Result<(), Self::Error>
+  where
+    Self: Sized,
+    T: SigningKey + Sync,
+  {
+    futures::executor::block_on(self.set_message_signature(signature_params, signing_key, signature_name))
+  }
+
+  fn set_message_signatures_sync<T>(
+    &mut self,
+    params_key_name: &[(&HttpSignatureParams, &T, Option<&str>)],
+  ) -> Result<(), Self::Error>
+  where
+    Self: Sized,
+    T: SigningKey + Sync,
+  {
+    futures::executor::block_on(self.set_message_signatures(params_key_name))
+  }
+
+  fn verify_message_signature_sync<T>(&self, verifying_key: &T, key_id: Option<&str>) -> Result<SignatureName, Self::Error>
+  where
+    Self: Sized,
+    T: VerifyingKey + Sync,
+  {
+    futures::executor::block_on(self.verify_message_signature(verifying_key, key_id))
+  }
+
+  fn verify_message_signatures_sync<T>(
+    &self,
+    key_and_id: &[(&T, Option<&str>)],
+  ) -> Result<Vec<Result<SignatureName, Self::Error>>, Self::Error>
+  where
+    Self: Sized,
+    T: VerifyingKey + Sync,
+  {
+    futures::executor::block_on(self.verify_message_signatures(key_and_id))
+  }
+}
+
+#[cfg(feature = "blocking")]
+impl<D> MessageSignatureResSync for Response<D>
+where
+  D: Send + Body + Sync,
+{
+  fn set_message_signature_sync<T, B>(
+    &mut self,
+    signature_params: &HttpSignatureParams,
+    signing_key: &T,
+    signature_name: Option<&str>,
+    req_for_param: Option<&Request<B>>,
+  ) -> Result<(), Self::Error>
+  where
+    Self: Sized,
+    T: SigningKey + Sync,
+    B: Sync,
+  {
+    futures::executor::block_on(self.set_message_signature(signature_params, signing_key, signature_name, req_for_param))
+  }
+
+  fn set_message_signatures_sync<T, B>(
+    &mut self,
+    params_key_name: &[(&HttpSignatureParams, &T, Option<&str>)],
+    req_for_param: Option<&Request<B>>,
+  ) -> Result<(), Self::Error>
+  where
+    Self: Sized,
+    T: SigningKey + Sync,
+    B: Sync,
+  {
+    futures::executor::block_on(self.set_message_signatures(params_key_name, req_for_param))
+  }
+
+  fn verify_message_signature_sync<T, B>(
+    &self,
+    verifying_key: &T,
+    key_id: Option<&str>,
+    req_for_param: Option<&Request<B>>,
+  ) -> Result<SignatureName, Self::Error>
+  where
+    Self: Sized,
+    T: VerifyingKey + Sync,
+    B: Sync,
+  {
+    futures::executor::block_on(self.verify_message_signature(verifying_key, key_id, req_for_param))
+  }
+
+  fn verify_message_signatures_sync<T, B>(
+    &self,
+    key_and_id: &[(&T, Option<&str>)],
+    req_for_param: Option<&Request<B>>,
+  ) -> Result<Vec<Result<SignatureName, Self::Error>>, Self::Error>
+  where
+    Self: Sized,
+    T: VerifyingKey + Sync,
+    B: Sync,
+  {
+    futures::executor::block_on(self.verify_message_signatures(key_and_id, req_for_param))
+  }
+}
+
 /* --------------------------------------- */
 // inner functions
 /// has message signature inner function
@@ -1026,4 +1220,36 @@ ii+31DW+YulmysZKQKDvuk96TARuWMO/vDbhk777a2QF3bgNoIj8UPMwnw==
     assert!(verification_res[0].as_ref().unwrap() == "eddsa_sig");
     assert!(verification_res[1].as_ref().unwrap() == "p256_sig");
   }
+
+  #[cfg(feature = "blocking")]
+  #[test]
+  fn test_blocking_set_verify_message_signature_req() {
+    let mut req = futures::executor::block_on(build_request());
+    let secret_key = SecretKey::from_pem(EDDSA_SECRET_KEY).unwrap();
+    let mut signature_params = HttpSignatureParams::try_new(&build_covered_components_req()).unwrap();
+    signature_params.set_key_info(&secret_key);
+
+    req.set_message_signature_sync(&signature_params, &secret_key, None).unwrap();
+
+    let public_key = PublicKey::from_pem(EDDSA_PUBLIC_KEY).unwrap();
+    let verification_res = req.verify_message_signature_sync(&public_key, None);
+    assert!(verification_res.is_ok());
+  }
+
+  #[cfg(feature = "blocking")]
+  #[test]
+  fn test_blocking_set_verify_message_signature_res() {
+    let req = futures::executor::block_on(build_request());
+    let mut res = futures::executor::block_on(build_response());
+    let secret_key = SecretKey::from_pem(EDDSA_SECRET_KEY).unwrap();
+    let mut signature_params = HttpSignatureParams::try_new(&build_covered_components_res()).unwrap();
+    signature_params.set_key_info(&secret_key);
+    res
+      .set_message_signature_sync(&signature_params, &secret_key, None, Some(&req))
+      .unwrap();
+
+    let public_key = PublicKey::from_pem(EDDSA_PUBLIC_KEY).unwrap();
+    let verification_res = res.verify_message_signature_sync(&public_key, None, Some(&req));
+    assert!(verification_res.is_ok());
+  }
 }

httpsig-hyper/src/lib.rs

@@ -42,7 +42,9 @@ impl std::str::FromStr for ContentDigestType {
 pub use error::{HyperDigestError, HyperDigestResult, HyperSigError, HyperSigResult};
 pub use httpsig::prelude;
 pub use hyper_content_digest::{ContentDigest, RequestContentDigest, ResponseContentDigest};
-pub use hyper_http::{MessageSignature, MessageSignatureReq, MessageSignatureRes};
+pub use hyper_http::{
+  MessageSignature, MessageSignatureReq, MessageSignatureReqSync, MessageSignatureRes, MessageSignatureResSync,
+};
 
 /* ----------------------------------------------------------------- */
 #[cfg(test)]
@@ -188,4 +190,50 @@ MCowBQYDK2VwAyEA1ixMQcxO46PLlgQfYS46ivFd+n0CcDHSKUnuhm3i1O0=
       .await;
     assert!(verification_res.is_err());
   }
+
+  #[cfg(feature = "blocking")]
+  #[test]
+  fn test_set_verify_request_sync() {
+    // show usage of set_message_signature_sync and verify_message_signature_sync
+
+    let mut req = futures::executor::block_on(build_request());
+    let secret_key = SecretKey::from_pem(EDDSA_SECRET_KEY).unwrap();
+    let covered_components = COVERED_COMPONENTS_REQ
+      .iter()
+      .map(|v| message_component::HttpMessageComponentId::try_from(*v))
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap();
+    let mut signature_params = HttpSignatureParams::try_new(&covered_components).unwrap();
+    // set key information, alg and keyid
+    signature_params.set_key_info(&secret_key);
+    // set signature
+    req.set_message_signature_sync(&signature_params, &secret_key, None).unwrap();
+    let public_key = PublicKey::from_pem(EDDSA_PUBLIC_KEY).unwrap();
+    let verification_res = req.verify_message_signature_sync(&public_key, None);
+    assert!(verification_res.is_ok());
+  }
+
+  #[cfg(feature = "blocking")]
+  #[test]
+  fn test_set_verify_response_sync() {
+    // show usage of set_message_signature_sync and verify_message_signature_sync
+    let req = futures::executor::block_on(build_request());
+    let mut res = futures::executor::block_on(build_response());
+    let secret_key = SecretKey::from_pem(EDDSA_SECRET_KEY).unwrap();
+    let covered_components = COVERED_COMPONENTS_RES
+      .iter()
+      .map(|v| message_component::HttpMessageComponentId::try_from(*v))
+      .collect::<Result<Vec<_>, _>>()
+      .unwrap();
+    let mut signature_params = HttpSignatureParams::try_new(&covered_components).unwrap();
+    // set key information, alg and keyid
+    signature_params.set_key_info(&secret_key);
+    // set signature
+    res
+      .set_message_signature_sync(&signature_params, &secret_key, None, Some(&req))
+      .unwrap();
+    let public_key = PublicKey::from_pem(EDDSA_PUBLIC_KEY).unwrap();
+    let verification_res = res.verify_message_signature_sync(&public_key, None, Some(&req));
+    assert!(verification_res.is_ok());
+  }
 }