Implement Error for graviola::Error

This makes it possible to use the `?` operator with `graviola::Error` in
application code that uses e.g. `anyhow`.

The required implementations of `core::fmt::Display` are simply based on
the docs for each variant, converted to the standard lowercase,
non-punctuated style.

This currently used `std::error::Error` instead of `core::error::Error`
because the latter would mean a `rust-version` bump up to 1.81.
Depending on what happens with #57, this could perhaps use some feature
flag(s) to conditionally use `std` or `core`. Or hide the entire trait
impl behind a feature flag.

Author: bsamseth

graviola/src/error.rs

@@ -48,3 +48,40 @@ impl From<KeyFormatError> for Error {
         Self::KeyFormatError(kfe)
     }
 }
+
+impl core::fmt::Display for KeyFormatError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::UnsupportedPkcs8Version => write!(f, "unsupported PKCS#8 version"),
+            Self::MismatchedPkcs8Algorithm => write!(f, "mismatched PKCS#8 algorithm"),
+            Self::MismatchedPkcs8Parameters => write!(f, "mismatched PKCS#8 parameters"),
+            Self::MismatchedSec1Curve => write!(f, "mismatched SEC1 curve"),
+            Self::MismatchedSec1PublicKey => write!(f, "mismatched SEC1 public key"),
+        }
+    }
+}
+
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::WrongLength => write!(f, "some slice was the wrong length"),
+            Self::NotUncompressed => write!(
+                f,
+                "a compressed elliptic curve point encoding was encountered"
+            ),
+            Self::NotOnCurve => write!(f, "a public key was invalid"),
+            Self::OutOfRange => write!(f, "a value was too small or large"),
+            Self::RngFailed => write!(
+                f,
+                "a random number generator returned an error or fixed values"
+            ),
+            Self::BadSignature => write!(f, "presented signature is invalid"),
+            Self::DecryptFailed => write!(f, "presented AEAD tag/aad/ciphertext/nonce was wrong"),
+            Self::Asn1Error(e) => write!(f, "an ASN.1 encoding/decoding error: {e}"),
+            Self::KeyFormatError(e) => write!(f, "a key formatting/validation error: {e}"),
+        }
+    }
+}
+
+impl std::error::Error for KeyFormatError {}
+impl std::error::Error for Error {}

graviola/src/high/asn1.rs

@@ -755,6 +755,25 @@ pub enum Error {
     UnhandledBitString,
 }
 
+impl core::fmt::Display for Error {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Error::UnexpectedTag => write!(f, "unexpected tag"),
+            Error::UnexpectedEof => write!(f, "unexpected end of input"),
+            Error::UnexpectedTrailingData => write!(f, "unexpected trailing data"),
+            Error::NonCanonicalEncoding => write!(f, "non-canonical encoding"),
+            Error::UnhandledEnumValue => write!(f, "unhandled enum value"),
+            Error::IntegerOutOfRange => write!(f, "integer out of range"),
+            Error::IllegalNull => write!(f, "illegal null"),
+            Error::UnsupportedLargeObjectId => write!(f, "unsupported large object identifier"),
+            Error::UnsupportedLargeObjectLength => write!(f, "unsupported large object length"),
+            Error::UnhandledBitString => write!(f, "unhandled bit string"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct Tag(u8);