abcrypt/
error.rs

1// SPDX-FileCopyrightText: 2022 Shun Sakai
2//
3// SPDX-License-Identifier: Apache-2.0 OR MIT
4
5//! Error types for this crate.
6
7use core::{fmt, result};
8
9use blake2::digest::MacError;
10
11/// The error type for the abcrypt encrypted data format.
12#[derive(Clone, Copy, Debug, Eq, PartialEq)]
13pub enum Error {
14    /// The encrypted data was shorter than 164 bytes.
15    InvalidLength,
16
17    /// The magic number (file signature) was invalid.
18    InvalidMagicNumber,
19
20    /// The version was the unsupported abcrypt version number.
21    UnsupportedVersion(u8),
22
23    /// The version was the unrecognized abcrypt version number.
24    UnknownVersion(u8),
25
26    /// The Argon2 type were invalid.
27    InvalidArgon2Type(u32),
28
29    /// The Argon2 version were invalid.
30    InvalidArgon2Version(u32),
31
32    /// The Argon2 parameters were invalid.
33    InvalidArgon2Params(argon2::Error),
34
35    /// The Argon2 context was invalid.
36    InvalidArgon2Context(argon2::Error),
37
38    /// The MAC (authentication tag) of the header was invalid.
39    InvalidHeaderMac(MacError),
40
41    /// The MAC (authentication tag) of the ciphertext was invalid.
42    InvalidMac(chacha20poly1305::Error),
43}
44
45impl fmt::Display for Error {
46    #[inline]
47    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
48        match self {
49            Self::InvalidLength => write!(f, "encrypted data is shorter than 164 bytes"),
50            Self::InvalidMagicNumber => write!(f, "invalid magic number"),
51            Self::UnsupportedVersion(version) => {
52                write!(f, "unsupported version number `{version}`")
53            }
54            Self::UnknownVersion(version) => write!(f, "unknown version number `{version}`"),
55            Self::InvalidArgon2Type(_) => write!(f, "invalid Argon2 type"),
56            Self::InvalidArgon2Version(version) => {
57                write!(f, "invalid Argon2 version `{version:#x}`")
58            }
59            Self::InvalidArgon2Params(_) => write!(f, "invalid Argon2 parameters"),
60            Self::InvalidArgon2Context(_) => write!(f, "invalid Argon2 context"),
61            Self::InvalidHeaderMac(_) => write!(f, "invalid header MAC"),
62            Self::InvalidMac(_) => write!(f, "invalid ciphertext MAC"),
63        }
64    }
65}
66
67#[cfg(feature = "std")]
68impl std::error::Error for Error {
69    #[inline]
70    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
71        match self {
72            Self::InvalidArgon2Params(err) | Self::InvalidArgon2Context(err) => Some(err),
73            Self::InvalidHeaderMac(err) => Some(err),
74            Self::InvalidMac(err) => Some(err),
75            _ => None,
76        }
77    }
78}
79
80impl From<MacError> for Error {
81    #[inline]
82    fn from(err: MacError) -> Self {
83        Self::InvalidHeaderMac(err)
84    }
85}
86
87impl From<chacha20poly1305::Error> for Error {
88    #[inline]
89    fn from(err: chacha20poly1305::Error) -> Self {
90        Self::InvalidMac(err)
91    }
92}
93
94/// A specialized [`Result`](result::Result) type for read and write operations
95/// for the abcrypt encrypted data format.
96///
97/// # Examples
98///
99/// ```
100/// # #[cfg(feature = "alloc")]
101/// # {
102/// use abcrypt::{Decryptor, Encryptor};
103///
104/// fn encrypt(plaintext: &[u8], passphrase: &[u8]) -> abcrypt::Result<Vec<u8>> {
105///     Encryptor::new(&plaintext, passphrase).map(|c| c.encrypt_to_vec())
106/// }
107///
108/// fn decrypt(ciphertext: &[u8], passphrase: &[u8]) -> abcrypt::Result<Vec<u8>> {
109///     Decryptor::new(&ciphertext, passphrase).and_then(|c| c.decrypt_to_vec())
110/// }
111///
112/// let data = b"Hello, world!\n";
113/// let passphrase = b"passphrase";
114///
115/// let ciphertext = encrypt(data, passphrase).unwrap();
116/// assert_ne!(ciphertext, data);
117///
118/// let plaintext = decrypt(&ciphertext, passphrase).unwrap();
119/// assert_eq!(plaintext, data);
120/// # }
121/// ```
122pub type Result<T> = result::Result<T, Error>;
123
124#[cfg(test)]
125mod tests {
126    use core::any;
127
128    use super::*;
129
130    #[test]
131    fn clone() {
132        assert_eq!(Error::InvalidLength.clone(), Error::InvalidLength);
133        assert_eq!(Error::InvalidMagicNumber.clone(), Error::InvalidMagicNumber);
134        assert_eq!(
135            Error::UnsupportedVersion(u8::MIN).clone(),
136            Error::UnsupportedVersion(u8::MIN)
137        );
138        assert_eq!(
139            Error::UnknownVersion(u8::MAX).clone(),
140            Error::UnknownVersion(u8::MAX)
141        );
142        assert_eq!(
143            Error::InvalidArgon2Type(u32::MAX).clone(),
144            Error::InvalidArgon2Type(u32::MAX)
145        );
146        assert_eq!(
147            Error::InvalidArgon2Version(u32::MAX).clone(),
148            Error::InvalidArgon2Version(u32::MAX)
149        );
150        assert_eq!(
151            Error::InvalidArgon2Params(argon2::Error::AdTooLong).clone(),
152            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
153        );
154        assert_eq!(
155            Error::InvalidArgon2Context(argon2::Error::AdTooLong).clone(),
156            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
157        );
158        assert_eq!(
159            Error::InvalidHeaderMac(MacError).clone(),
160            Error::InvalidHeaderMac(MacError)
161        );
162        assert_eq!(
163            Error::InvalidMac(chacha20poly1305::Error).clone(),
164            Error::InvalidMac(chacha20poly1305::Error)
165        );
166    }
167
168    #[test]
169    fn copy() {
170        {
171            let a = Error::InvalidLength;
172            let b = a;
173            assert_eq!(a, b);
174        }
175
176        {
177            let a = Error::InvalidMagicNumber;
178            let b = a;
179            assert_eq!(a, b);
180        }
181
182        {
183            let a = Error::UnsupportedVersion(u8::MIN);
184            let b = a;
185            assert_eq!(a, b);
186        }
187
188        {
189            let a = Error::UnknownVersion(u8::MAX);
190            let b = a;
191            assert_eq!(a, b);
192        }
193
194        {
195            let a = Error::InvalidArgon2Type(u32::MAX);
196            let b = a;
197            assert_eq!(a, b);
198        }
199
200        {
201            let a = Error::InvalidArgon2Version(u32::MAX);
202            let b = a;
203            assert_eq!(a, b);
204        }
205
206        {
207            let a = Error::InvalidArgon2Params(argon2::Error::AdTooLong);
208            let b = a;
209            assert_eq!(a, b);
210        }
211
212        {
213            let a = Error::InvalidArgon2Context(argon2::Error::AdTooLong);
214            let b = a;
215            assert_eq!(a, b);
216        }
217
218        {
219            let a = Error::InvalidHeaderMac(MacError);
220            let b = a;
221            assert_eq!(a, b);
222        }
223
224        {
225            let a = Error::InvalidMac(chacha20poly1305::Error);
226            let b = a;
227            assert_eq!(a, b);
228        }
229    }
230
231    #[cfg(feature = "alloc")]
232    #[test]
233    fn debug() {
234        assert_eq!(format!("{:?}", Error::InvalidLength), "InvalidLength");
235        assert_eq!(
236            format!("{:?}", Error::InvalidMagicNumber),
237            "InvalidMagicNumber"
238        );
239        assert_eq!(
240            format!("{:?}", Error::UnsupportedVersion(u8::MIN)),
241            "UnsupportedVersion(0)"
242        );
243        assert_eq!(
244            format!("{:?}", Error::UnknownVersion(u8::MAX)),
245            "UnknownVersion(255)"
246        );
247        assert_eq!(
248            format!("{:?}", Error::InvalidArgon2Type(u32::MAX)),
249            "InvalidArgon2Type(4294967295)"
250        );
251        assert_eq!(
252            format!("{:?}", Error::InvalidArgon2Version(u32::MAX)),
253            "InvalidArgon2Version(4294967295)"
254        );
255        assert_eq!(
256            format!("{:?}", Error::InvalidArgon2Params(argon2::Error::AdTooLong)),
257            "InvalidArgon2Params(AdTooLong)"
258        );
259        assert_eq!(
260            format!(
261                "{:?}",
262                Error::InvalidArgon2Context(argon2::Error::AdTooLong)
263            ),
264            "InvalidArgon2Context(AdTooLong)"
265        );
266        assert_eq!(
267            format!("{:?}", Error::InvalidHeaderMac(MacError)),
268            "InvalidHeaderMac(MacError)"
269        );
270        assert_eq!(
271            format!("{:?}", Error::InvalidMac(chacha20poly1305::Error)),
272            "InvalidMac(Error)"
273        );
274    }
275
276    #[test]
277    fn equality() {
278        assert_eq!(Error::InvalidLength, Error::InvalidLength);
279        assert_ne!(Error::InvalidLength, Error::InvalidMagicNumber);
280        assert_ne!(Error::InvalidLength, Error::UnsupportedVersion(u8::MIN));
281        assert_ne!(Error::InvalidLength, Error::UnknownVersion(u8::MAX));
282        assert_ne!(Error::InvalidLength, Error::InvalidArgon2Type(u32::MAX));
283        assert_ne!(Error::InvalidLength, Error::InvalidArgon2Version(u32::MAX));
284        assert_ne!(
285            Error::InvalidLength,
286            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
287        );
288        assert_ne!(
289            Error::InvalidLength,
290            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
291        );
292        assert_ne!(Error::InvalidLength, Error::InvalidHeaderMac(MacError));
293        assert_ne!(
294            Error::InvalidLength,
295            Error::InvalidMac(chacha20poly1305::Error)
296        );
297        assert_ne!(Error::InvalidMagicNumber, Error::InvalidLength);
298        assert_eq!(Error::InvalidMagicNumber, Error::InvalidMagicNumber);
299        assert_ne!(
300            Error::InvalidMagicNumber,
301            Error::UnsupportedVersion(u8::MIN)
302        );
303        assert_ne!(Error::InvalidMagicNumber, Error::UnknownVersion(u8::MAX));
304        assert_ne!(
305            Error::InvalidMagicNumber,
306            Error::InvalidArgon2Type(u32::MAX)
307        );
308        assert_ne!(
309            Error::InvalidMagicNumber,
310            Error::InvalidArgon2Version(u32::MAX)
311        );
312        assert_ne!(
313            Error::InvalidMagicNumber,
314            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
315        );
316        assert_ne!(
317            Error::InvalidMagicNumber,
318            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
319        );
320        assert_ne!(Error::InvalidMagicNumber, Error::InvalidHeaderMac(MacError));
321        assert_ne!(
322            Error::InvalidMagicNumber,
323            Error::InvalidMac(chacha20poly1305::Error)
324        );
325        assert_ne!(Error::UnsupportedVersion(u8::MIN), Error::InvalidLength);
326        assert_ne!(
327            Error::UnsupportedVersion(u8::MIN),
328            Error::InvalidMagicNumber
329        );
330        assert_eq!(
331            Error::UnsupportedVersion(u8::MIN),
332            Error::UnsupportedVersion(u8::MIN)
333        );
334        assert_ne!(
335            Error::UnsupportedVersion(u8::MIN),
336            Error::UnknownVersion(u8::MAX)
337        );
338        assert_ne!(
339            Error::UnsupportedVersion(u8::MIN),
340            Error::InvalidArgon2Type(u32::MAX)
341        );
342        assert_ne!(
343            Error::UnsupportedVersion(u8::MIN),
344            Error::InvalidArgon2Version(u32::MAX)
345        );
346        assert_ne!(
347            Error::UnsupportedVersion(u8::MIN),
348            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
349        );
350        assert_ne!(
351            Error::UnsupportedVersion(u8::MIN),
352            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
353        );
354        assert_ne!(
355            Error::UnsupportedVersion(u8::MIN),
356            Error::InvalidHeaderMac(MacError)
357        );
358        assert_ne!(
359            Error::UnsupportedVersion(u8::MIN),
360            Error::InvalidMac(chacha20poly1305::Error)
361        );
362        assert_ne!(Error::UnknownVersion(u8::MAX), Error::InvalidLength);
363        assert_ne!(Error::UnknownVersion(u8::MAX), Error::InvalidMagicNumber);
364        assert_ne!(
365            Error::UnknownVersion(u8::MAX),
366            Error::UnsupportedVersion(u8::MIN)
367        );
368        assert_eq!(
369            Error::UnknownVersion(u8::MAX),
370            Error::UnknownVersion(u8::MAX)
371        );
372        assert_ne!(
373            Error::UnknownVersion(u8::MAX),
374            Error::InvalidArgon2Type(u32::MAX)
375        );
376        assert_ne!(
377            Error::UnknownVersion(u8::MAX),
378            Error::InvalidArgon2Version(u32::MAX)
379        );
380        assert_ne!(
381            Error::UnknownVersion(u8::MAX),
382            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
383        );
384        assert_ne!(
385            Error::UnknownVersion(u8::MAX),
386            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
387        );
388        assert_ne!(
389            Error::UnknownVersion(u8::MAX),
390            Error::InvalidHeaderMac(MacError)
391        );
392        assert_ne!(
393            Error::UnknownVersion(u8::MAX),
394            Error::InvalidMac(chacha20poly1305::Error)
395        );
396        assert_ne!(Error::InvalidArgon2Type(u32::MAX), Error::InvalidLength);
397        assert_ne!(
398            Error::InvalidArgon2Type(u32::MAX),
399            Error::InvalidMagicNumber
400        );
401        assert_ne!(
402            Error::InvalidArgon2Type(u32::MAX),
403            Error::UnsupportedVersion(u8::MIN)
404        );
405        assert_ne!(
406            Error::InvalidArgon2Type(u32::MAX),
407            Error::UnknownVersion(u8::MAX)
408        );
409        assert_eq!(
410            Error::InvalidArgon2Type(u32::MAX),
411            Error::InvalidArgon2Type(u32::MAX)
412        );
413        assert_ne!(
414            Error::InvalidArgon2Type(u32::MAX),
415            Error::InvalidArgon2Version(u32::MAX)
416        );
417        assert_ne!(
418            Error::InvalidArgon2Type(u32::MAX),
419            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
420        );
421        assert_ne!(
422            Error::InvalidArgon2Type(u32::MAX),
423            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
424        );
425        assert_ne!(
426            Error::InvalidArgon2Type(u32::MAX),
427            Error::InvalidHeaderMac(MacError)
428        );
429        assert_ne!(
430            Error::InvalidArgon2Type(u32::MAX),
431            Error::InvalidMac(chacha20poly1305::Error)
432        );
433        assert_ne!(Error::InvalidArgon2Version(u32::MAX), Error::InvalidLength);
434        assert_ne!(
435            Error::InvalidArgon2Version(u32::MAX),
436            Error::InvalidMagicNumber
437        );
438        assert_ne!(
439            Error::InvalidArgon2Version(u32::MAX),
440            Error::UnsupportedVersion(u8::MIN)
441        );
442        assert_ne!(
443            Error::InvalidArgon2Version(u32::MAX),
444            Error::UnknownVersion(u8::MAX)
445        );
446        assert_ne!(
447            Error::InvalidArgon2Version(u32::MAX),
448            Error::InvalidArgon2Type(u32::MAX)
449        );
450        assert_eq!(
451            Error::InvalidArgon2Version(u32::MAX),
452            Error::InvalidArgon2Version(u32::MAX)
453        );
454        assert_ne!(
455            Error::InvalidArgon2Version(u32::MAX),
456            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
457        );
458        assert_ne!(
459            Error::InvalidArgon2Version(u32::MAX),
460            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
461        );
462        assert_ne!(
463            Error::InvalidArgon2Version(u32::MAX),
464            Error::InvalidHeaderMac(MacError)
465        );
466        assert_ne!(
467            Error::InvalidArgon2Version(u32::MAX),
468            Error::InvalidMac(chacha20poly1305::Error)
469        );
470        assert_ne!(
471            Error::InvalidArgon2Params(argon2::Error::AdTooLong),
472            Error::InvalidLength
473        );
474        assert_ne!(
475            Error::InvalidArgon2Params(argon2::Error::AdTooLong),
476            Error::InvalidMagicNumber
477        );
478        assert_ne!(
479            Error::InvalidArgon2Params(argon2::Error::AdTooLong),
480            Error::UnsupportedVersion(u8::MIN)
481        );
482        assert_ne!(
483            Error::InvalidArgon2Params(argon2::Error::AdTooLong),
484            Error::UnknownVersion(u8::MAX)
485        );
486        assert_ne!(
487            Error::InvalidArgon2Params(argon2::Error::AdTooLong),
488            Error::InvalidArgon2Type(u32::MAX)
489        );
490        assert_ne!(
491            Error::InvalidArgon2Params(argon2::Error::AdTooLong),
492            Error::InvalidArgon2Version(u32::MAX)
493        );
494        assert_eq!(
495            Error::InvalidArgon2Params(argon2::Error::AdTooLong),
496            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
497        );
498        assert_ne!(
499            Error::InvalidArgon2Params(argon2::Error::AdTooLong),
500            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
501        );
502        assert_ne!(
503            Error::InvalidArgon2Params(argon2::Error::AdTooLong),
504            Error::InvalidHeaderMac(MacError)
505        );
506        assert_ne!(
507            Error::InvalidArgon2Params(argon2::Error::AdTooLong),
508            Error::InvalidMac(chacha20poly1305::Error)
509        );
510        assert_ne!(
511            Error::InvalidArgon2Context(argon2::Error::AdTooLong),
512            Error::InvalidLength
513        );
514        assert_ne!(
515            Error::InvalidArgon2Context(argon2::Error::AdTooLong),
516            Error::InvalidMagicNumber
517        );
518        assert_ne!(
519            Error::InvalidArgon2Context(argon2::Error::AdTooLong),
520            Error::UnsupportedVersion(u8::MIN)
521        );
522        assert_ne!(
523            Error::InvalidArgon2Context(argon2::Error::AdTooLong),
524            Error::UnknownVersion(u8::MAX)
525        );
526        assert_ne!(
527            Error::InvalidArgon2Context(argon2::Error::AdTooLong),
528            Error::InvalidArgon2Type(u32::MAX)
529        );
530        assert_ne!(
531            Error::InvalidArgon2Context(argon2::Error::AdTooLong),
532            Error::InvalidArgon2Version(u32::MAX)
533        );
534        assert_ne!(
535            Error::InvalidArgon2Context(argon2::Error::AdTooLong),
536            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
537        );
538        assert_eq!(
539            Error::InvalidArgon2Context(argon2::Error::AdTooLong),
540            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
541        );
542        assert_ne!(
543            Error::InvalidArgon2Context(argon2::Error::AdTooLong),
544            Error::InvalidHeaderMac(MacError)
545        );
546        assert_ne!(
547            Error::InvalidArgon2Context(argon2::Error::AdTooLong),
548            Error::InvalidMac(chacha20poly1305::Error)
549        );
550        assert_ne!(Error::InvalidHeaderMac(MacError), Error::InvalidLength);
551        assert_ne!(Error::InvalidHeaderMac(MacError), Error::InvalidMagicNumber);
552        assert_ne!(
553            Error::InvalidHeaderMac(MacError),
554            Error::UnsupportedVersion(u8::MIN)
555        );
556        assert_ne!(
557            Error::InvalidHeaderMac(MacError),
558            Error::UnknownVersion(u8::MAX)
559        );
560        assert_ne!(
561            Error::InvalidHeaderMac(MacError),
562            Error::InvalidArgon2Type(u32::MAX)
563        );
564        assert_ne!(
565            Error::InvalidHeaderMac(MacError),
566            Error::InvalidArgon2Version(u32::MAX)
567        );
568        assert_ne!(
569            Error::InvalidHeaderMac(MacError),
570            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
571        );
572        assert_ne!(
573            Error::InvalidHeaderMac(MacError),
574            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
575        );
576        assert_eq!(
577            Error::InvalidHeaderMac(MacError),
578            Error::InvalidHeaderMac(MacError)
579        );
580        assert_ne!(
581            Error::InvalidHeaderMac(MacError),
582            Error::InvalidMac(chacha20poly1305::Error)
583        );
584        assert_ne!(
585            Error::InvalidMac(chacha20poly1305::Error),
586            Error::InvalidLength
587        );
588        assert_ne!(
589            Error::InvalidMac(chacha20poly1305::Error),
590            Error::InvalidMagicNumber
591        );
592        assert_ne!(
593            Error::InvalidMac(chacha20poly1305::Error),
594            Error::UnsupportedVersion(u8::MIN)
595        );
596        assert_ne!(
597            Error::InvalidMac(chacha20poly1305::Error),
598            Error::UnknownVersion(u8::MAX)
599        );
600        assert_ne!(
601            Error::InvalidMac(chacha20poly1305::Error),
602            Error::InvalidArgon2Type(u32::MAX)
603        );
604        assert_ne!(
605            Error::InvalidMac(chacha20poly1305::Error),
606            Error::InvalidArgon2Version(u32::MAX)
607        );
608        assert_ne!(
609            Error::InvalidMac(chacha20poly1305::Error),
610            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
611        );
612        assert_ne!(
613            Error::InvalidMac(chacha20poly1305::Error),
614            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
615        );
616        assert_ne!(
617            Error::InvalidMac(chacha20poly1305::Error),
618            Error::InvalidHeaderMac(MacError)
619        );
620        assert_eq!(
621            Error::InvalidMac(chacha20poly1305::Error),
622            Error::InvalidMac(chacha20poly1305::Error)
623        );
624    }
625
626    #[cfg(feature = "alloc")]
627    #[test]
628    fn display() {
629        assert_eq!(
630            format!("{}", Error::InvalidLength),
631            "encrypted data is shorter than 164 bytes"
632        );
633        assert_eq!(
634            format!("{}", Error::InvalidMagicNumber),
635            "invalid magic number"
636        );
637        assert_eq!(
638            format!("{}", Error::UnsupportedVersion(u8::MIN)),
639            "unsupported version number `0`"
640        );
641        assert_eq!(
642            format!("{}", Error::UnknownVersion(u8::MAX)),
643            "unknown version number `255`"
644        );
645        assert_eq!(
646            format!("{}", Error::InvalidArgon2Type(u32::MAX)),
647            "invalid Argon2 type"
648        );
649        assert_eq!(
650            format!("{}", Error::InvalidArgon2Version(u32::MAX)),
651            "invalid Argon2 version `0xffffffff`"
652        );
653        assert_eq!(
654            format!("{}", Error::InvalidArgon2Params(argon2::Error::AdTooLong)),
655            "invalid Argon2 parameters"
656        );
657        assert_eq!(
658            format!("{}", Error::InvalidArgon2Context(argon2::Error::AdTooLong)),
659            "invalid Argon2 context"
660        );
661        assert_eq!(
662            format!("{}", Error::InvalidHeaderMac(MacError)),
663            "invalid header MAC"
664        );
665        assert_eq!(
666            format!("{}", Error::InvalidMac(chacha20poly1305::Error)),
667            "invalid ciphertext MAC"
668        );
669    }
670
671    #[cfg(feature = "std")]
672    #[test]
673    fn source() {
674        use std::error::Error as _;
675
676        assert!(Error::InvalidLength.source().is_none());
677        assert!(Error::InvalidMagicNumber.source().is_none());
678        assert!(Error::UnsupportedVersion(u8::MIN).source().is_none());
679        assert!(Error::UnknownVersion(u8::MAX).source().is_none());
680        assert!(Error::InvalidArgon2Type(u32::MAX).source().is_none());
681        assert!(Error::InvalidArgon2Version(u32::MAX).source().is_none());
682        assert!(
683            Error::InvalidArgon2Params(argon2::Error::AdTooLong)
684                .source()
685                .unwrap()
686                .is::<argon2::Error>()
687        );
688        assert!(
689            Error::InvalidArgon2Context(argon2::Error::AdTooLong)
690                .source()
691                .unwrap()
692                .is::<argon2::Error>()
693        );
694        assert!(
695            Error::InvalidHeaderMac(MacError)
696                .source()
697                .unwrap()
698                .is::<MacError>()
699        );
700        assert!(
701            Error::InvalidMac(chacha20poly1305::Error)
702                .source()
703                .unwrap()
704                .is::<chacha20poly1305::Error>()
705        );
706    }
707
708    #[test]
709    fn from_mac_error_to_error() {
710        assert_eq!(Error::from(MacError), Error::InvalidHeaderMac(MacError));
711    }
712
713    #[test]
714    fn from_chacha20poly1305_error_to_error() {
715        assert_eq!(
716            Error::from(chacha20poly1305::Error),
717            Error::InvalidMac(chacha20poly1305::Error)
718        );
719    }
720
721    #[test]
722    fn result_type() {
723        assert_eq!(
724            any::type_name::<Result<()>>(),
725            any::type_name::<result::Result<(), Error>>()
726        );
727        assert_eq!(
728            any::type_name::<Result<u8>>(),
729            any::type_name::<result::Result<u8, Error>>()
730        );
731    }
732}
abcrypt/error.rs

abcrypt/
error.rs
