opaque_vx/
errors.rs

1// SPDX-License-Identifier: MIT OR Apache-2.0
2// Copyright (c) VexaHub and contributors.
3// Copyright (c) Meta Platforms, Inc. and affiliates.
4
5//! A list of error types which are produced during an execution of the protocol
6use core::convert::Infallible;
7use core::error::Error;
8use core::fmt::Debug;
9
10use displaydoc::Display;
11
12/// Represents an error in the manipulation of internal cryptographic data
13#[derive(Clone, Copy, Display, Eq, Hash, Ord, PartialEq, PartialOrd)]
14pub enum InternalError {
15    /// Size of input is empty or longer then [`u16::MAX`].
16    HashToScalar,
17    /// Computing HKDF failed while deriving subkeys
18    HkdfError,
19    /// Computing HMAC failed while supplying a secret key
20    HmacError,
21    /// Computing the key stretching function failed
22    KsfError,
23    /// Error while performing a KEM operation
24    KemError,
25    /** This error occurs when the envelope seal open hmac check fails
26    HMAC check in seal open failed. */
27    SealOpenHmacError,
28    /** This error occurs when attempting to open an envelope of the wrong
29    type (base mode, custom identifier) */
30    IncompatibleEnvelopeModeError,
31    /// Error from the OPRF evaluation
32    OprfError(voprf::Error),
33    /// Error from the OPRF evaluation
34    OprfInternalError(voprf::InternalError),
35}
36
37impl Debug for InternalError {
38    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
39        match self {
40            Self::HashToScalar => f.debug_tuple("HashToScalar").finish(),
41            Self::HkdfError => f.debug_tuple("HkdfError").finish(),
42            Self::HmacError => f.debug_tuple("HmacError").finish(),
43            Self::KsfError => f.debug_tuple("KsfError").finish(),
44            Self::KemError => f.debug_tuple("KemError").finish(),
45            Self::SealOpenHmacError => f.debug_tuple("SealOpenHmacError").finish(),
46            Self::IncompatibleEnvelopeModeError => {
47                f.debug_tuple("IncompatibleEnvelopeModeError").finish()
48            }
49            Self::OprfError(error) => f.debug_tuple("OprfError").field(error).finish(),
50            Self::OprfInternalError(error) => {
51                f.debug_tuple("OprfInternalError").field(error).finish()
52            }
53        }
54    }
55}
56
57impl Error for InternalError {}
58
59impl From<voprf::Error> for InternalError {
60    fn from(voprf_error: voprf::Error) -> Self {
61        Self::OprfError(voprf_error)
62    }
63}
64
65impl From<voprf::Error> for ProtocolError {
66    fn from(voprf_error: voprf::Error) -> Self {
67        Self::LibraryError(InternalError::OprfError(voprf_error))
68    }
69}
70
71impl From<voprf::InternalError> for ProtocolError {
72    fn from(voprf_error: voprf::InternalError) -> Self {
73        Self::LibraryError(InternalError::OprfInternalError(voprf_error))
74    }
75}
76
77/// Represents an error in protocol handling
78#[derive(Clone, Copy, Display, Eq, Hash, Ord, PartialEq, PartialOrd)]
79pub enum ProtocolError<T = Infallible> {
80    /// Internal error encountered
81    LibraryError(InternalError),
82    /// Error in validating credentials
83    InvalidLoginError,
84    /// Error with serializing / deserializing protocol messages
85    SerializationError,
86    /** Invalid length for `{name}`: expected {len}, actual {actual_len} */
87    #[allow(clippy::doc_markdown, unused_assignments)]
88    SizeError {
89        /// name
90        name: &'static str,
91        /// length
92        len: usize,
93        /// actual
94        actual_len: usize,
95    },
96    /** This error occurs when the client detects that the server has
97    reflected the OPRF value (beta == alpha) */
98    ReflectedValueError,
99    /// Custom [`SecretKey`](crate::keypair::PrivateKeySerialization) error type
100    Custom(T),
101}
102
103impl<T: Debug> Debug for ProtocolError<T> {
104    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
105        match self {
106            Self::LibraryError(pake_error) => {
107                f.debug_tuple("LibraryError").field(pake_error).finish()
108            }
109            Self::InvalidLoginError => f.debug_tuple("InvalidLoginError").finish(),
110            Self::SerializationError => f.debug_tuple("SerializationError").finish(),
111            Self::SizeError {
112                name,
113                len,
114                actual_len,
115            } => f
116                .debug_struct("SizeError")
117                .field("name", name)
118                .field("len", len)
119                .field("actual_len", actual_len)
120                .finish(),
121            Self::ReflectedValueError => f.debug_tuple("ReflectedValueError").finish(),
122            Self::Custom(custom) => f.debug_tuple("Custom").field(custom).finish(),
123        }
124    }
125}
126
127impl<T: Error> Error for ProtocolError<T> {}
128
129// This is meant to express future(ly) non-trivial ways of converting the
130// internal error into a ProtocolError
131impl<T> From<InternalError> for ProtocolError<T> {
132    fn from(e: InternalError) -> ProtocolError<T> {
133        Self::LibraryError(e)
134    }
135}
136
137// See https://github.com/rust-lang/rust/issues/64715 and remove this when merged,
138// and https://github.com/dtolnay/thiserror/issues/62 for why this comes up in our
139// doc tests.
140impl<T> From<Infallible> for ProtocolError<T> {
141    fn from(_: Infallible) -> Self {
142        unreachable!()
143    }
144}
145
146impl ProtocolError {
147    /// Convert `ProtocolError<Infallible>` into `ProtocolError<T>`
148    pub fn into_custom<T>(self) -> ProtocolError<T> {
149        match self {
150            Self::LibraryError(internal_error) => ProtocolError::LibraryError(internal_error),
151            Self::InvalidLoginError => ProtocolError::InvalidLoginError,
152            Self::SerializationError => ProtocolError::SerializationError,
153            Self::SizeError {
154                name,
155                len,
156                actual_len,
157            } => ProtocolError::SizeError {
158                name,
159                len,
160                actual_len,
161            },
162            Self::ReflectedValueError => ProtocolError::ReflectedValueError,
163            Self::Custom(infallible) => match infallible {},
164        }
165    }
166}
opaque_vx/errors.rs

opaque_vx/
errors.rs
