co-didcomm 0.8.0

COKIT fork of didcomm-rs — DIDComm messaging v2 implementation with modern crypto and WASM support.
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
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

use crate::{
    helpers::create_fallback_getter,
    messages::helpers::{serialization_base64_buffer, serialization_base64_jwm_header},
    Jwk,
    JwmHeader,
};

/// Signature data for [JWS](https://datatracker.ietf.org/doc/html/rfc7515) envelopes.
/// They can be used per recipient in [General JWS JSON](https://datatracker.ietf.org/doc/html/rfc7515#section-7.2.1),
/// triggered by using [`.as_jws`][crate::Message::as_jws()] or as a single signature for the entire JWS in
/// [Flattened JWS JSON](https://datatracker.ietf.org/doc/html/rfc7515#section-7.2.2), triggered by
/// [`.as_flat_jws`][crate::Message::as_flat_jws()].
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Signature {
    /// integrity protected header elements
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(with = "serialization_base64_jwm_header")]
    pub protected: Option<JwmHeader>,

    /// header elements that are not integrity protected
    #[serde(skip_serializing_if = "Option::is_none")]
    pub header: Option<JwmHeader>,

    /// signature computed over protected header elements
    #[serde(default)]
    #[serde(with = "serialization_base64_buffer")]
    pub signature: Vec<u8>,
}

impl Signature {
    /// Creates a new `Signature` that can be used in JWS `signatures` property or
    /// as top-level (flattened) property in flattened JWS JSON serialization.
    ///
    /// # Arguments
    ///
    /// * `protected` - JWM header protected by signing
    ///
    /// * `header` - JWM header not protected by signing
    ///
    /// * `signature` - signature over JWS payload and protected header
    pub fn new(
        protected: Option<JwmHeader>,
        header: Option<JwmHeader>,
        signature: Vec<u8>,
    ) -> Self {
        Signature {
            protected,
            header,
            signature,
        }
    }

    create_fallback_getter!(header, protected, alg, String);

    create_fallback_getter!(header, protected, cty, String);

    create_fallback_getter!(header, protected, enc, String);

    create_fallback_getter!(header, protected, epk, Jwk);

    create_fallback_getter!(header, protected, jku, String);

    create_fallback_getter!(header, protected, jwk, Jwk);

    create_fallback_getter!(header, protected, kid, String);

    create_fallback_getter!(header, protected, skid, String);
}

/// A struct to generate and serialize [JWS](https://datatracker.ietf.org/doc/html/rfc7515)
/// envelopes for DIDComm messages.
#[derive(Serialize, Deserialize, Debug)]
pub struct Jws {
    /// base64 encoded payload of the JWS
    pub payload: String,

    /// Top-level signature for flat JWS JSON messages.
    /// Will be ignored if `signatures` is not `None`
    #[serde(flatten)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<Signature>,

    /// Pre-recipient signatures for flat JWS JSON messages.
    /// If not `None`, will be preferred over `signature`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signatures: Option<Vec<Signature>>,
}

impl Jws {
    /// Creates a new [general JWS](https://datatracker.ietf.org/doc/html/rfc7515#section-7.2.1)
    /// object with signature values per recipient.
    ///
    /// # Arguments
    ///
    /// * `payload` - payload with encoded data
    ///
    /// * `signatures` - signature values per recipient
    pub fn new(payload: String, signatures: Vec<Signature>) -> Self {
        Jws {
            payload,
            signature: None,
            signatures: Some(signatures),
        }
    }

    /// Creates a new [flattened JWS](https://datatracker.ietf.org/doc/html/rfc7515#section-7.2.2)
    /// object with signature information on JWS' top level.
    ///
    /// # Arguments
    ///
    /// * `payload` - payload with encoded data
    ///
    /// * `signatures_value` - signature value that is used on JWS top-level
    pub fn new_flat(payload: String, signature_value: Signature) -> Self {
        Jws {
            payload,
            signature: Some(signature_value),
            signatures: None,
        }
    }
}