perf: use static strings for static error messages

Author: DXist

httpsig-hyper/src/error.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use httpsig::prelude::HttpSigError;
 use thiserror::Error;
 
@@ -9,7 +11,7 @@ pub type HyperSigResult<T> = std::result::Result<T, HyperSigError>;
 pub enum HyperSigError {
   /// No signature headers found
   #[error("No signature headers found: {0}")]
-  NoSignatureHeaders(String),
+  NoSignatureHeaders(&'static str),
 
   /// Failed to parse signature headers
   #[error("Failed to stringify signature headers: {0}")]
@@ -21,15 +23,15 @@ pub enum HyperSigError {
 
   /// Invalid component name
   #[error("Invalid component name: {0}")]
-  InvalidComponentName(String),
+  InvalidComponentName(Cow<'static, str>),
 
   /// Invalid component param
   #[error("Invalid component param: {0}")]
   InvalidComponentParam(String),
 
   /// Invalid signature
   #[error("Invalid signature: {0}")]
-  InvalidSignature(String),
+  InvalidSignature(&'static str),
 
   /// Inherited from HttpSigError
   #[error("HttpSigError: {0}")]

httpsig-hyper/src/hyper_http.rs

@@ -337,7 +337,7 @@ where
   {
     if !self.has_message_signature() {
       return Err(HyperSigError::NoSignatureHeaders(
-        "The request does not have signature and signature-input headers".to_string(),
+        "The request does not have signature and signature-input headers",
       ));
     }
     let map_signature_with_base = self.extract_signatures()?;
@@ -468,7 +468,7 @@ where
   {
     if !self.has_message_signature() {
       return Err(HyperSigError::NoSignatureHeaders(
-        "The response does not have signature and signature-input headers".to_string(),
+        "The response does not have signature and signature-input headers",
       ));
     }
     let map_signature_with_base = self.extract_signatures(req_for_param)?;
@@ -615,8 +615,8 @@ fn get_alg_key_ids_inner<B>(
       let alg = headers
         .signature_params()
         .alg
-        .clone()
-        .map(|a| AlgorithmName::from_str(&a))
+        .as_ref()
+        .map(|a| AlgorithmName::from_str(a))
         .transpose()
         .ok()
         .flatten();
@@ -646,11 +646,11 @@ fn extract_signatures_inner<B1, B2>(
 ) -> HyperSigResult<IndexMap<SignatureName, (HttpSignatureBase, HttpSignatureHeaders)>> {
   let signature_headers_map = extract_signature_headers_with_name(req_or_res)?;
   let extracted = signature_headers_map
-    .iter()
+    .into_iter()
     .filter_map(|(name, headers)| {
       build_signature_base(req_or_res, headers.signature_params(), req_for_param)
         .ok()
-        .map(|base| (name.clone(), (base, headers.clone())))
+        .map(|base| (name, (base, headers)))
     })
     .collect();
   Ok(extracted)
@@ -679,7 +679,7 @@ where
     async move {
       if filtered.is_empty() {
         return Err(HyperSigError::NoSignatureHeaders(
-          "No signature as appropriate target for verification".to_string(),
+          "No signature as appropriate target for verification",
         ));
       }
       // check if any one of the signature headers is valid
@@ -690,9 +690,7 @@ where
       if !successful_sig_names.is_empty() {
         Ok(successful_sig_names.first().unwrap().clone())
       } else {
-        Err(HyperSigError::InvalidSignature(
-          "Invalid signature for the verifying key".to_string(),
-        ))
+        Err(HyperSigError::InvalidSignature("Invalid signature for the verifying key"))
       }
     }
   });
@@ -712,16 +710,14 @@ impl<B> RequestOrResponse<'_, B> {
   fn method(&self) -> HyperSigResult<&http::Method> {
     match self {
       RequestOrResponse::Request(req) => Ok(req.method()),
-      _ => Err(HyperSigError::InvalidComponentName(
-        "`method` is only for request".to_string(),
-      )),
+      _ => Err(HyperSigError::InvalidComponentName("`method` is only for request".into())),
     }
   }
 
   fn uri(&self) -> HyperSigResult<&http::Uri> {
     match self {
       RequestOrResponse::Request(req) => Ok(req.uri()),
-      _ => Err(HyperSigError::InvalidComponentName("`uri` is only for request".to_string())),
+      _ => Err(HyperSigError::InvalidComponentName("`uri` is only for request".into())),
     }
   }
 
@@ -735,9 +731,7 @@ impl<B> RequestOrResponse<'_, B> {
   fn status(&self) -> HyperSigResult<http::StatusCode> {
     match self {
       RequestOrResponse::Response(res) => Ok(res.status()),
-      _ => Err(HyperSigError::InvalidComponentName(
-        "`status` is only for response".to_string(),
-      )),
+      _ => Err(HyperSigError::InvalidComponentName("`status` is only for response".into())),
     }
   }
 }
@@ -747,7 +741,7 @@ fn extract_signature_headers_with_name<B>(req_or_res: &RequestOrResponse<B>) ->
   let headers = req_or_res.headers();
   if !(headers.contains_key("signature-input") && headers.contains_key("signature")) {
     return Err(HyperSigError::NoSignatureHeaders(
-      "The request does not have signature and signature-input headers".to_string(),
+      "The request does not have signature and signature-input headers",
     ));
   };
 
@@ -800,14 +794,14 @@ fn build_signature_base<B1, B2>(
     })
     .collect::<Result<Vec<_>, _>>()?;
 
-  HttpSignatureBase::try_new(&component_lines, signature_params).map_err(|e| e.into())
+  HttpSignatureBase::try_new(component_lines, signature_params).map_err(|e| e.into())
 }
 
 /// Extract http field from hyper http request/response
 fn extract_http_field<B>(req_or_res: &RequestOrResponse<B>, id: &HttpMessageComponentId) -> HyperSigResult<HttpMessageComponent> {
   let HttpMessageComponentName::HttpField(header_name) = &id.name else {
     return Err(HyperSigError::InvalidComponentName(
-      "invalid http message component name as http field".to_string(),
+      "invalid http message component name as http field".into(),
     ));
   };
   let headers = match req_or_res {
@@ -821,7 +815,7 @@ fn extract_http_field<B>(req_or_res: &RequestOrResponse<B>, id: &HttpMessageComp
     .map(|v| v.to_str().map(|s| s.to_owned()))
     .collect::<Result<Vec<_>, _>>()?;
 
-  HttpMessageComponent::try_from((id, field_values.as_slice())).map_err(|e| e.into())
+  HttpMessageComponent::try_from((id, field_values)).map_err(|e| e.into())
 }
 
 /// Extract derived component from hyper http request/response
@@ -831,7 +825,7 @@ fn extract_derived_component<B>(
 ) -> HyperSigResult<HttpMessageComponent> {
   let HttpMessageComponentName::Derived(derived_id) = &id.name else {
     return Err(HyperSigError::InvalidComponentName(
-      "invalid http message component name as derived component".to_string(),
+      "invalid http message component name as derived component".into(),
     ));
   };
   // Validate parameters allowed on derived components (RFC 9421).
@@ -860,9 +854,7 @@ fn extract_derived_component<B>(
   match req_or_res {
     RequestOrResponse::Request(_) => {
       if matches!(derived_id, DerivedComponentName::Status) {
-        return Err(HyperSigError::InvalidComponentName(
-          "`status` is only for response".to_string(),
-        ));
+        return Err(HyperSigError::InvalidComponentName("`status` is only for response".into()));
       }
     }
     RequestOrResponse::Response(_) => {
@@ -874,7 +866,7 @@ fn extract_derived_component<B>(
         && !has_req
       {
         return Err(HyperSigError::InvalidComponentName(
-          "derived components other than `@status` and `@signature-params` require `req` parameter for response".to_string(),
+          "derived components other than `@status` and `@signature-params` require `req` parameter for response".into(),
         ));
       }
       // `@status` must not have `req` parameter
@@ -924,7 +916,7 @@ fn extract_derived_component<B>(
       .collect::<Vec<_>>(),
   };
 
-  HttpMessageComponent::try_from((id, field_values.as_slice())).map_err(|e| e.into())
+  HttpMessageComponent::try_from((id, field_values)).map_err(|e| e.into())
 }
 
 /* --------------------------------------- */

httpsig-hyper/src/hyper_http_tests.rs

@@ -116,7 +116,7 @@ async fn test_extract_signature_params_from_request() {
   let component = extract_http_message_component(&req_or_res, &component_id).unwrap();
   assert_eq!(component.to_string(), "\"@signature-params\": (\"@method\" \"@authority\")");
   assert_eq!(component.value.to_string(), r##"("@method" "@authority")"##);
-  assert_eq!(component.value.as_field_value(), r##"sig1=("@method" "@authority")"##);
+  assert_eq!(component.value.to_field_value(), r##"sig1=("@method" "@authority")"##);
   assert_eq!(component.value.as_component_value(), r##"("@method" "@authority")"##);
   assert_eq!(component.value.key(), Some("sig1"));
 }

httpsig/src/error.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use thiserror::Error;
 
 /// Result type for http signature
@@ -38,16 +40,16 @@ pub enum HttpSigError {
   InvalidComponentId(String),
   /// Invalid http message component
   #[error("Invalid http message component: {0}")]
-  InvalidComponent(String),
+  InvalidComponent(Cow<'static, str>),
 
   /* ----- Signature params errors ----- */
   /// Invalid signature params
   #[error("Invalid signature params: {0}")]
-  InvalidSignatureParams(String),
+  InvalidSignatureParams(&'static str),
 
   /// Error in building signature header
   #[error("Failed to build signature header: {0}")]
-  BuildSignatureHeaderError(String),
+  BuildSignatureHeaderError(&'static str),
 
   /// Error in building signature base
   #[error("Failed to build signature base: {0}")]

httpsig/src/lib.rs

@@ -122,7 +122,7 @@ Signature: sig-b26=:wqcAqbmYJ2ji2glfAMaRy4gruYYnx2nEFN2HN6jrnDnQCK1u02Gb04v9EDgw
       .map(|&line| message_component::HttpMessageComponent::try_from(line).unwrap())
       .collect::<Vec<_>>();
 
-    let signature_base = HttpSignatureBase::try_new(&component_lines, &signature_params).unwrap();
+    let signature_base = HttpSignatureBase::try_new(component_lines, &signature_params).unwrap();
     let sk = SecretKey::from_pem(&AlgorithmName::Ed25519, EDDSA_SECRET_KEY).unwrap();
     let pk = PublicKey::from_pem(&AlgorithmName::Ed25519, EDDSA_PUBLIC_KEY).unwrap();
 
@@ -140,7 +140,7 @@ Signature: sig-b26=:wqcAqbmYJ2ji2glfAMaRy4gruYYnx2nEFN2HN6jrnDnQCK1u02Gb04v9EDgw
 
     // sender
     let signature_params = HttpSignatureParams::try_from(SIGNATURE_PARAMS).unwrap();
-    let signature_base = HttpSignatureBase::try_new(&component_lines, &signature_params).unwrap();
+    let signature_base = HttpSignatureBase::try_new(component_lines.clone(), &signature_params).unwrap();
     let sk = SecretKey::from_pem(&AlgorithmName::Ed25519, EDDSA_SECRET_KEY).unwrap();
     let signature_headers = signature_base.build_signature_headers(&sk, Some("sig-b26")).unwrap();
     let signature_params_header_string = signature_headers.signature_input_header_value();
@@ -153,7 +153,7 @@ Signature: sig-b26=:wqcAqbmYJ2ji2glfAMaRy4gruYYnx2nEFN2HN6jrnDnQCK1u02Gb04v9EDgw
     let header_map = HttpSignatureHeaders::try_parse(&signature_header_string, &signature_params_header_string).unwrap();
     let received_signature_headers = header_map.get("sig-b26").unwrap();
     let received_signature_base =
-      HttpSignatureBase::try_new(&component_lines, received_signature_headers.signature_params()).unwrap();
+      HttpSignatureBase::try_new(component_lines, received_signature_headers.signature_params()).unwrap();
     let pk = PublicKey::from_pem(&AlgorithmName::Ed25519, EDDSA_PUBLIC_KEY).unwrap();
     let verification_result = received_signature_base.verify_signature_headers(&pk, received_signature_headers);
     assert!(verification_result.is_ok());