wolfcose 0.1.0

Safe Rust API for wolfSSL wolfCOSE.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use crate::raw;
use core::fmt;

/// Result type used by this crate.
pub type Result<T> = core::result::Result<T, Error>;

/// wolfCOSE error code wrapper.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum Error {
    /// Invalid argument.
    InvalidArgument,
    /// Output or scratch buffer was too small.
    BufferTooSmall,
    /// Malformed CBOR input.
    CborMalformed,
    /// Unexpected CBOR type.
    CborType,
    /// CBOR integer or length overflow.
    CborOverflow,
    /// CBOR nesting exceeded configured limit.
    CborDepth,
    /// Bad COSE tag.
    CoseBadTag,
    /// Bad or unsupported COSE algorithm.
    CoseBadAlgorithm,
    /// Signature verification failed.
    CoseSignatureFailed,
    /// Decryption failed.
    CoseDecryptFailed,
    /// Bad COSE header.
    CoseBadHeader,
    /// COSE key type mismatch.
    CoseKeyType,
    /// COSE MAC verification failed.
    CoseMacFailed,
    /// wolfCrypt error.
    Crypto,
    /// Unsupported operation or algorithm.
    Unsupported,
    /// MAC verification failed.
    MacFailed,
    /// Detached payload/ciphertext was required but absent.
    DetachedPayload,
    /// Unknown raw wolfCOSE return code.
    Unknown(i32),
}

impl Error {
    /// Convert a raw wolfCOSE status code into a Rust result.
    pub fn from_code(code: i32) -> Result<()> {
        if code == raw::WOLFCOSE_SUCCESS as i32 {
            Ok(())
        } else {
            Err(Self::from(code))
        }
    }

    /// Return the raw wolfCOSE error code.
    pub fn code(self) -> i32 {
        match self {
            Self::InvalidArgument => raw::WOLFCOSE_E_INVALID_ARG,
            Self::BufferTooSmall => raw::WOLFCOSE_E_BUFFER_TOO_SMALL,
            Self::CborMalformed => raw::WOLFCOSE_E_CBOR_MALFORMED,
            Self::CborType => raw::WOLFCOSE_E_CBOR_TYPE,
            Self::CborOverflow => raw::WOLFCOSE_E_CBOR_OVERFLOW,
            Self::CborDepth => raw::WOLFCOSE_E_CBOR_DEPTH,
            Self::CoseBadTag => raw::WOLFCOSE_E_COSE_BAD_TAG,
            Self::CoseBadAlgorithm => raw::WOLFCOSE_E_COSE_BAD_ALG,
            Self::CoseSignatureFailed => raw::WOLFCOSE_E_COSE_SIG_FAIL,
            Self::CoseDecryptFailed => raw::WOLFCOSE_E_COSE_DECRYPT_FAIL,
            Self::CoseBadHeader => raw::WOLFCOSE_E_COSE_BAD_HDR,
            Self::CoseKeyType => raw::WOLFCOSE_E_COSE_KEY_TYPE,
            Self::CoseMacFailed => raw::WOLFCOSE_E_COSE_MAC_FAIL,
            Self::Crypto => raw::WOLFCOSE_E_CRYPTO,
            Self::Unsupported => raw::WOLFCOSE_E_UNSUPPORTED,
            Self::MacFailed => raw::WOLFCOSE_E_MAC_FAIL,
            Self::DetachedPayload => raw::WOLFCOSE_E_DETACHED_PAYLOAD,
            Self::Unknown(code) => code,
        }
    }
}

impl From<i32> for Error {
    fn from(code: i32) -> Self {
        match code {
            raw::WOLFCOSE_E_INVALID_ARG => Self::InvalidArgument,
            raw::WOLFCOSE_E_BUFFER_TOO_SMALL => Self::BufferTooSmall,
            raw::WOLFCOSE_E_CBOR_MALFORMED => Self::CborMalformed,
            raw::WOLFCOSE_E_CBOR_TYPE => Self::CborType,
            raw::WOLFCOSE_E_CBOR_OVERFLOW => Self::CborOverflow,
            raw::WOLFCOSE_E_CBOR_DEPTH => Self::CborDepth,
            raw::WOLFCOSE_E_COSE_BAD_TAG => Self::CoseBadTag,
            raw::WOLFCOSE_E_COSE_BAD_ALG => Self::CoseBadAlgorithm,
            raw::WOLFCOSE_E_COSE_SIG_FAIL => Self::CoseSignatureFailed,
            raw::WOLFCOSE_E_COSE_DECRYPT_FAIL => Self::CoseDecryptFailed,
            raw::WOLFCOSE_E_COSE_BAD_HDR => Self::CoseBadHeader,
            raw::WOLFCOSE_E_COSE_KEY_TYPE => Self::CoseKeyType,
            raw::WOLFCOSE_E_COSE_MAC_FAIL => Self::CoseMacFailed,
            raw::WOLFCOSE_E_CRYPTO => Self::Crypto,
            raw::WOLFCOSE_E_UNSUPPORTED => Self::Unsupported,
            raw::WOLFCOSE_E_MAC_FAIL => Self::MacFailed,
            raw::WOLFCOSE_E_DETACHED_PAYLOAD => Self::DetachedPayload,
            other => Self::Unknown(other),
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "wolfCOSE error {}", self.code())
    }
}

#[cfg(feature = "std")]
impl std::error::Error for Error {}