jose-b64 0.1.2

Base64 utilities for use in JOSE crates
Documentation 
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

// SPDX-FileCopyrightText: 2022 Profian Inc. <opensource@profian.com>
// SPDX-License-Identifier: Apache-2.0 OR MIT

#![cfg(feature = "secret")]

use alloc::boxed::Box;
use core::fmt::Debug;
use core::ops::{Deref, DerefMut};

use base64ct::Base64UrlUnpadded;
use serde::{Deserialize, Serialize};
use subtle::ConstantTimeEq;
use zeroize::{Zeroize, Zeroizing};

use super::Bytes;

/// A serde wrapper for base64-encoded secrets.
///
/// A secret is like the [`Bytes`] type, with some additional protections:
///
///   1. It is zeroed on drop.
///   2. Its equality implementation is constant time.
///   2. Its contents are not printed in the debug formatter.
#[derive(Clone, Serialize, Deserialize)]
#[serde(transparent)]
#[serde(bound(serialize = "Bytes<T, E>: Serialize"))]
#[serde(bound(deserialize = "Bytes<T, E>: Deserialize<'de>"))]
pub struct Secret<T: Zeroize = Box<[u8]>, E = Base64UrlUnpadded>(Zeroizing<Bytes<T, E>>);

impl<T: Zeroize, E> Debug for Secret<T, E> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "Secret(***)")
    }
}

impl<T: Zeroize, U: Into<Bytes<T, E>>, E> From<U> for Secret<T, E> {
    fn from(value: U) -> Self {
        Self(Zeroizing::new(value.into()))
    }
}

impl<T: Zeroize, E> Deref for Secret<T, E> {
    type Target = Bytes<T, E>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T: Zeroize, E> DerefMut for Secret<T, E> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<T: Zeroize, U, E> AsRef<U> for Secret<T, E>
where
    Bytes<T, E>: AsRef<U>,
{
    fn as_ref(&self) -> &U {
        self.0.as_ref()
    }
}

impl<T: Zeroize, U, E> AsMut<U> for Secret<T, E>
where
    Bytes<T, E>: AsMut<U>,
{
    fn as_mut(&mut self) -> &mut U {
        self.0.as_mut()
    }
}

impl<T: Zeroize + AsRef<[u8]> + Sized, E> ConstantTimeEq for Secret<T, E> {
    fn ct_eq(&self, other: &Self) -> subtle::Choice {
        self.0.as_ref().ct_eq(other.0.as_ref())
    }
}

impl<T: Zeroize + AsRef<[u8]>, E> Eq for Secret<T, E> {}
impl<T: Zeroize + AsRef<[u8]>, E> PartialEq for Secret<T, E> {
    fn eq(&self, other: &Self) -> bool {
        self.ct_eq(other).unwrap_u8() == 1
    }
}