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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

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

//! JWS Cryptographic Implementation

mod core;

use alloc::{vec, vec::Vec};

use jose_b64::stream::Update;
use rand_core::RngCore;

use crate::{Flattened, General, Jws, Protected, Signature, Unprotected};

/// Signature creation state
pub trait Signer: Update {
    #[allow(missing_docs)]
    type FinishError: From<Self::Error>;

    /// Finish processing payload and create the signature.
    fn finish(self, rng: impl 'static + RngCore) -> Result<Signature, Self::FinishError>;
}

/// A signature creation key
pub trait SigningKey<'a> {
    #[allow(missing_docs)]
    type StartError: From<<Self::Signer as Update>::Error>;

    /// The state object used during signing.
    type Signer: Signer;

    /// Begin the signature creation process.
    fn sign(
        &'a self,
        prot: Option<Protected>,
        head: Option<Unprotected>,
    ) -> Result<Self::Signer, Self::StartError>;
}

/// Signature verification state
pub trait Verifier<'a>: Update {
    #[allow(missing_docs)]
    type FinishError: From<Self::Error>;

    /// Finish processing payload and verify the signature.
    fn finish(self) -> Result<(), Self::FinishError>;
}

impl<'a, T: Verifier<'a>> Verifier<'a> for Vec<T>
where
    T::FinishError: Default,
{
    type FinishError = T::FinishError;

    fn finish(self) -> Result<(), Self::FinishError> {
        let mut last = T::FinishError::default();

        for x in self {
            match x.finish() {
                Ok(()) => return Ok(()),
                Err(e) => last = e,
            }
        }

        Err(last)
    }
}

/// A signature verification key
pub trait VerifyingKey<'a, T> {
    #[allow(missing_docs)]
    type StartError: From<<Self::Verifier as Update>::Error>;

    /// The state object used during signing.
    type Verifier: Verifier<'a>;

    /// Begin the signature verification process.
    fn verify(&'a self, val: T) -> Result<Self::Verifier, Self::StartError>;
}

impl<'a, A, T, V> VerifyingKey<'a, A> for [T]
where
    T: VerifyingKey<'a, A, Verifier = Vec<V>>,
    V::FinishError: Default,
    V: Verifier<'a>,
    V: Update,
    A: Copy,
{
    type StartError = T::StartError;
    type Verifier = Vec<V>;

    fn verify(&'a self, val: A) -> Result<Self::Verifier, Self::StartError> {
        let mut all = Vec::new();

        for key in self {
            all.extend(key.verify(val)?);
        }

        Ok(all)
    }
}

impl<'a, T: VerifyingKey<'a, &'a Signature>> VerifyingKey<'a, &'a Flattened> for T
where
    <T::Verifier as Verifier<'a>>::FinishError: Default,
{
    type StartError = T::StartError;
    type Verifier = Vec<T::Verifier>;

    fn verify(&'a self, flattened: &'a Flattened) -> Result<Self::Verifier, Self::StartError> {
        Ok(vec![self.verify(&flattened.signature)?])
    }
}

impl<'a, T: VerifyingKey<'a, &'a Signature>> VerifyingKey<'a, &'a General> for T
where
    <T::Verifier as Verifier<'a>>::FinishError: Default,
{
    type StartError = T::StartError;
    type Verifier = Vec<T::Verifier>;

    fn verify(&'a self, general: &'a General) -> Result<Self::Verifier, Self::StartError> {
        general
            .signatures
            .iter()
            .map(|sig| self.verify(sig))
            .collect()
    }
}

impl<'a, T, V, E> VerifyingKey<'a, &'a Jws> for T
where
    T: VerifyingKey<'a, &'a Flattened, Verifier = V, StartError = E>,
    T: VerifyingKey<'a, &'a General, Verifier = V, StartError = E>,
    E: From<V::Error>,
    V: Verifier<'a>,
{
    type StartError = E;
    type Verifier = V;

    fn verify(&'a self, jws: &'a Jws) -> Result<Self::Verifier, Self::StartError> {
        match jws {
            Jws::General(general) => self.verify(general),
            Jws::Flattened(flattened) => self.verify(flattened),
        }
    }
}