jwt-compact 0.5.0

Minimalistic JWT implementation with focus on type safety and secure cryptographic primitives
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

//! Provides compatibility layer for using `digest 0.10` digests where `digest 0.9` traits
//! are required. Motivated by `k256` and `rsa` crates depending on `digest 0.9`.

#[cfg(feature = "k256")]
use k256::ecdsa::digest as digest_legacy;

use digest_legacy::{generic_array::GenericArray, BlockInput, FixedOutput, Reset, Update};
use sha2::digest::{self, crypto_common::BlockSizeUser, Output};

/// Thin wrapper around a `digest 0.10` hash digest. Implements traits from both 0.9 and 0.10.
#[derive(Debug, Clone, Copy, Default)]
#[repr(transparent)]
pub(crate) struct Compat<T>(T);

impl<T: digest::Update> Update for Compat<T> {
    fn update(&mut self, data: impl AsRef<[u8]>) {
        <T as digest::Update>::update(&mut self.0, data.as_ref());
    }
}

impl<T: digest::Update> digest::Update for Compat<T> {
    fn update(&mut self, data: &[u8]) {
        <T as digest::Update>::update(&mut self.0, data);
    }
}

impl<T> FixedOutput for Compat<T>
where
    T: digest::FixedOutputReset,
{
    type OutputSize = <T as digest::OutputSizeUser>::OutputSize;

    fn finalize_into(self, out: &mut GenericArray<u8, Self::OutputSize>) {
        <T as digest::FixedOutput>::finalize_into(self.0, out);
    }

    fn finalize_into_reset(&mut self, out: &mut GenericArray<u8, Self::OutputSize>) {
        <T as digest::FixedOutputReset>::finalize_into_reset(&mut self.0, out);
    }
}

impl<T: digest::OutputSizeUser> digest::OutputSizeUser for Compat<T> {
    type OutputSize = <T as digest::OutputSizeUser>::OutputSize;
}

impl<T: digest::FixedOutput> digest::FixedOutput for Compat<T> {
    fn finalize_into(self, out: &mut Output<Self>) {
        <T as digest::FixedOutput>::finalize_into(self.0, out);
    }
}

impl<T: digest::Reset> digest::Reset for Compat<T> {
    fn reset(&mut self) {
        <T as digest::Reset>::reset(&mut self.0);
    }
}

impl<T: digest::Reset> Reset for Compat<T> {
    fn reset(&mut self) {
        <T as digest::Reset>::reset(&mut self.0);
    }
}

impl<T: digest::FixedOutputReset> digest::FixedOutputReset for Compat<T> {
    fn finalize_into_reset(&mut self, out: &mut Output<Self>) {
        <T as digest::FixedOutputReset>::finalize_into_reset(&mut self.0, out);
    }
}

impl<T: digest::HashMarker> digest::HashMarker for Compat<T> {}

impl<T: BlockSizeUser> BlockInput for Compat<T> {
    type BlockSize = <T as BlockSizeUser>::BlockSize;
}