keri_controller/identifier/
signing.rs

1use cesrox::ParsedData;
2use keri_core::{
3    event::sections::seal::EventSeal,
4    event_message::signature::{Signature, SignerData},
5    prefix::{IndexedSignature, SelfSigningPrefix},
6};
7
8use crate::error::ControllerError;
9
10use super::Identifier;
11
12impl Identifier {
13    pub fn sign_with_index(
14        &self,
15        signature: SelfSigningPrefix,
16        key_index: u16,
17    ) -> Result<Signature, ControllerError> {
18        let last_establishment = self
19            .known_events
20            .storage
21            .get_last_establishment_event_seal(&self.id)
22            .ok_or(ControllerError::UnknownIdentifierError)?;
23        let sig_data = SignerData::EventSeal(last_establishment);
24        let indexes_sig = IndexedSignature::new_both_same(signature, key_index);
25        Ok(Signature::Transferable(sig_data, vec![indexes_sig]))
26    }
27
28    // Returns transferable signature of provided data.
29    pub fn sign_data(
30        &self,
31        data: &[u8],
32        signatures: &[SelfSigningPrefix],
33    ) -> Result<Signature, ControllerError> {
34        let event_seal = self.get_last_establishment_event_seal()?;
35        self.transferable_signature(data, event_seal, signatures)
36    }
37
38    /// Helper function that produces transferable signature made with
39    /// keys corresponding to event in kel that is specified with event_seal. It
40    /// computes indexes of provided `SelfSigningIdentifier`s and build `Signature`
41    /// from them.
42    fn transferable_signature(
43        &self,
44        data: &[u8],
45        event_seal: EventSeal,
46        signatures: &[SelfSigningPrefix],
47    ) -> Result<Signature, ControllerError> {
48        let state = self
49            .known_events
50            .get_state(&self.id)
51            .unwrap()
52            .current
53            .public_keys;
54        let indexed_signatures: Option<Vec<_>> = signatures
55            .iter()
56            .map(|sig| {
57                (
58                    sig,
59                    (state.iter().position(|bp| match bp.verify(data, sig).ok() {
60                        Some(result) => result,
61                        None => false,
62                    })),
63                )
64            })
65            .map(|(sig, index)| {
66                index.map(|i| IndexedSignature::new_both_same(sig.clone(), i as u16))
67            })
68            .collect();
69        let signature = Signature::Transferable(
70            SignerData::EventSeal(event_seal),
71            indexed_signatures.expect("Provided signatures do not match any of the keys corresponding to the provided event seal"),
72        );
73        Ok(signature)
74    }
75
76    // Returns CESR stream of signed data and signatures.
77    pub fn sign_to_cesr(
78        &self,
79        data: &str,
80        signatures: &[SelfSigningPrefix],
81    ) -> Result<String, ControllerError> {
82        // Sign data
83        let signature = self.sign_data(data.as_bytes(), signatures)?;
84        ParsedData {
85            payload: cesrox::payload::Payload::JSON(data.into()),
86            attachments: vec![signature.into()],
87        }
88        .to_cesr()
89        .map(|data| String::from_utf8(data).unwrap())
90        .map_err(|_e| ControllerError::CesrFormatError)
91    }
92
93    pub fn sign_with_index_to_cesr(
94        &self,
95        data: &str,
96        signature: SelfSigningPrefix,
97        key_index: u16,
98    ) -> Result<String, ControllerError> {
99        // Sign data
100        let signature = self.sign_with_index(signature, key_index)?;
101        ParsedData {
102            payload: cesrox::payload::Payload::JSON(data.into()),
103            attachments: vec![signature.into()],
104        }
105        .to_cesr()
106        .map(|data| String::from_utf8(data).unwrap())
107        .map_err(|_e| ControllerError::CesrFormatError)
108    }
109
110    pub fn verify_from_cesr(&self, stream: &[u8]) -> Result<(), ControllerError> {
111        self.known_events.verify_from_cesr(stream)
112    }
113}