Convert from anyhow to thiserror

Cargo.toml

@@ -12,14 +12,15 @@ keywords = ["security", "authentication"]
 categories = ["authentication"]
 
 [dependencies]
-anyhow = "1"
+thiserror = "1"
 base64 = "0.22"
 hex = "0.4"
 lazy-regex = "3"
 rsa = "0.9.0"
 regex = { version = "1", default_features = false, features = ["std"] }
 sha2 = { version = "0.10", features = ["oid"] }
 urlencoding = "2"
+spki = "0.7"
 
 [dev-dependencies]
 serde = { version = "1", features = ["derive"] }

src/lib.rs

@@ -1,3 +1,4 @@
-pub mod signable;
+pub mod mauth_error;
+pub(crate) mod signable;
 pub mod signer;
 pub mod verifier;

src/mauth_error.rs

@@ -0,0 +1,19 @@
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum MAuthError {
+    #[error("Unable to handle the URL as the format was invalid: {0}")]
+    UrlFormatError(#[from] std::string::FromUtf8Error),
+    #[error("Version {0} is not supported")]
+    UnsupportedVersion(u8),
+    #[error("Unable to parse RSA private key: {0}")]
+    PrivateKeyDecodeError(#[from] rsa::pkcs1::Error),
+    #[error("Unable to parse RSA public key: {0}")]
+    PublicKeyDecodeError(#[from] spki::Error),
+    #[error("RSA algorithm error: {0}")]
+    RsaSignError(#[from] rsa::Error),
+    #[error("Unable to verify RSA signature: {0}")]
+    SignatureVerifyError(#[from] rsa::signature::Error),
+    #[error("Unable to decode base64-encoded signature: {0}")]
+    SignatureDecodeError(#[from] base64::DecodeError),
+}

src/signable.rs

@@ -1,4 +1,4 @@
-use anyhow::Result;
+use crate::mauth_error::MAuthError;
 use lazy_regex::*;
 use regex::{Captures, Regex};
 use sha2::{Digest, Sha512};
@@ -38,7 +38,7 @@ impl<'a> Signable<'a> {
         }
     }
 
-    pub fn signing_string_v1(&self) -> Result<Vec<u8>> {
+    pub fn signing_string_v1(&self) -> Result<Vec<u8>, MAuthError> {
         let mut hasher = Sha512::default();
 
         hasher.update(&self.verb);
@@ -54,7 +54,7 @@ impl<'a> Signable<'a> {
         Ok(hex::encode(hasher.finalize()).into_bytes())
     }
 
-    pub fn signing_string_v2(&self) -> Result<Vec<u8>> {
+    pub fn signing_string_v2(&self) -> Result<Vec<u8>, MAuthError> {
         let encoded_query: String = Self::encode_query(&self.query)?;
         let body_digest = hex::encode(Sha512::digest(self.body));
 
@@ -70,14 +70,14 @@ impl<'a> Signable<'a> {
         .into_bytes())
     }
 
-    fn encode_query(qstr: &str) -> Result<String> {
+    fn encode_query(qstr: &str) -> Result<String, MAuthError> {
         if qstr.is_empty() {
             return Ok("".to_string());
         }
         let mut temp_param_list = qstr
             .split('&')
             .map(Self::split_equal_and_decode)
-            .collect::<Result<Vec<[String; 2]>>>()?;
+            .collect::<Result<Vec<[String; 2]>, MAuthError>>()?;
 
         temp_param_list.sort();
 
@@ -109,15 +109,15 @@ impl<'a> Signable<'a> {
         }
     }
 
-    fn split_equal_and_decode(value: &str) -> Result<[String; 2]> {
+    fn split_equal_and_decode(value: &str) -> Result<[String; 2], MAuthError> {
         let (k, v) = value.split_once('=').unwrap_or((value, ""));
         Ok([
             Self::replace_plus_and_decode(k)?,
             Self::replace_plus_and_decode(v)?,
         ])
     }
 
-    fn replace_plus_and_decode(value: &str) -> Result<String> {
+    fn replace_plus_and_decode(value: &str) -> Result<String, MAuthError> {
         Ok(decode(&value.replace('+', " "))?.into_owned())
     }
 }

src/signer.rs

@@ -1,5 +1,4 @@
-use crate::signable::Signable;
-use anyhow::{bail, Result};
+use crate::{mauth_error::MAuthError, signable::Signable};
 use base64::{engine::general_purpose, Engine as _};
 use rsa::pkcs1::DecodeRsaPrivateKey;
 use rsa::RsaPrivateKey;
@@ -13,7 +12,7 @@ pub struct Signer {
 }
 
 impl Signer {
-    pub fn new(app_uuid: impl Into<String>, private_key_data: String) -> Result<Self> {
+    pub fn new(app_uuid: impl Into<String>, private_key_data: String) -> Result<Self, MAuthError> {
         let private_key = RsaPrivateKey::from_pkcs1_pem(&private_key_data)?;
         let signing_key = rsa::pkcs1v15::SigningKey::<Sha512>::new(private_key.to_owned());
 
@@ -32,25 +31,25 @@ impl Signer {
         query: impl Into<String>,
         body: &[u8],
         timestamp: impl Into<String>,
-    ) -> Result<String> {
+    ) -> Result<String, MAuthError> {
         let signable = Signable::new(verb, path, query, body, timestamp, &self.app_uuid);
 
         match version {
             1 => self.sign_string_v1(&signable),
             2 => self.sign_string_v2(&signable),
-            _ => bail!("Version {version} is not supported."),
+            v => Err(MAuthError::UnsupportedVersion(v)),
         }
     }
 
-    fn sign_string_v1(&self, signable: &Signable) -> Result<String> {
+    fn sign_string_v1(&self, signable: &Signable) -> Result<String, MAuthError> {
         let signature = self.private_key.sign(
             rsa::Pkcs1v15Sign::new_unprefixed(),
             &signable.signing_string_v1()?,
         )?;
         Ok(general_purpose::STANDARD.encode(signature))
     }
 
-    fn sign_string_v2(&self, signable: &Signable) -> Result<String> {
+    fn sign_string_v2(&self, signable: &Signable) -> Result<String, MAuthError> {
         use rsa::signature::{SignatureEncoding, Signer};
 
         let sign = self.signing_key.sign(&signable.signing_string_v2()?);

src/verifier.rs

@@ -1,5 +1,4 @@
-use crate::signable::Signable;
-use anyhow::{bail, Result};
+use crate::{mauth_error::MAuthError, signable::Signable};
 use base64::{engine::general_purpose, Engine as _};
 use rsa::pkcs1v15::Signature;
 use rsa::pkcs8::DecodePublicKey;
@@ -14,7 +13,7 @@ pub struct Verifier {
 }
 
 impl Verifier {
-    pub fn new(app_uuid: impl Into<String>, public_key_data: String) -> Result<Self> {
+    pub fn new(app_uuid: impl Into<String>, public_key_data: String) -> Result<Self, MAuthError> {
         let public_key = RsaPublicKey::from_public_key_pem(&public_key_data)?;
         let verifying_key = rsa::pkcs1v15::VerifyingKey::<Sha512>::new(public_key.to_owned());
 
@@ -34,34 +33,42 @@ impl Verifier {
         body: &[u8],
         timestamp: impl Into<String>,
         signature: impl Into<String>,
-    ) -> Result<bool> {
+    ) -> Result<(), MAuthError> {
         let signable = Signable::new(verb, path, query, body, timestamp, &self.app_uuid);
 
         match version {
             1 => self.verify_signature_v1(&signable, signature.into()),
             2 => self.verify_signature_v2(&signable, signature.into()),
-            _ => bail!("Version {version} is not supported."),
+            v => Err(MAuthError::UnsupportedVersion(v)),
         }
     }
 
-    fn verify_signature_v1(&self, signable: &Signable, signature: String) -> Result<bool> {
+    fn verify_signature_v1(
+        &self,
+        signable: &Signable,
+        signature: String,
+    ) -> Result<(), MAuthError> {
         self.public_key.verify(
             rsa::Pkcs1v15Sign::new_unprefixed(),
             &signable.signing_string_v1()?,
             &general_purpose::STANDARD.decode(signature)?,
         )?;
 
-        Ok(true)
+        Ok(())
     }
 
-    fn verify_signature_v2(&self, signable: &Signable, signature: String) -> Result<bool> {
+    fn verify_signature_v2(
+        &self,
+        signable: &Signable,
+        signature: String,
+    ) -> Result<(), MAuthError> {
         use rsa::signature::Verifier;
 
         let signature =
             Signature::try_from(general_purpose::STANDARD.decode(signature)?.as_slice())?;
         self.verifying_key
             .verify(&signable.signing_string_v2()?, &signature)?;
 
-        Ok(true)
+        Ok(())
     }
 }

tests/protocol_test_suite.rs

@@ -88,15 +88,9 @@ fn test_verifier(
         _ => vec![],
     };
 
-    let result = verifier
+    verifier
         .verify_signature(version, req.verb, path, query, &body_data, timestamp, sig)
-        .unwrap();
-
-    if result {
-        Ok(())
-    } else {
-        Err(format!("[{test_case}] failed"))
-    }
+        .map_err(|_| format!("[{test_case}] failed"))
 }
 
 #[test]